diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3d8c44b77..d823a6f30 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -94,7 +94,6 @@ jobs:
             -DCMAKE_CXX_COMPILER="$(which clang++-${LLVM_VER})" \
             -DClang_DIR=${LLVM_PREFIX_DIR}/lib/cmake/clang \
             -DLLVM_DIR=${LLVM_PREFIX_DIR}/lib/cmake/llvm \
-            -DMLIR_DIR=${LLVM_PREFIX_DIR}/lib/cmake/mlir \
             -DMX_USE_VENDORED_CLANG=OFF \
             -GNinja \
             ./
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b446f876e..28c6193a2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -90,14 +90,9 @@ find_package(glog CONFIG REQUIRED GLOBAL)
 find_package(reproc++ CONFIG REQUIRED GLOBAL)
 find_package(RocksDB CONFIG REQUIRED GLOBAL)
 find_package(LLVM CONFIG REQUIRED GLOBAL)
-find_package(MLIR CONFIG REQUIRED GLOBAL)
-find_package(VAST CONFIG REQUIRED GLOBAL)
 find_package(Clang CONFIG REQUIRED GLOBAL)
 find_package(pasta CONFIG REQUIRED GLOBAL)
 
-include("cmake/mlir.cmake")
-include("cmake/vast.cmake")
-
 if(MX_ENABLE_PYTHON_BINDINGS)
   find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Embed)
 endif(MX_ENABLE_PYTHON_BINDINGS)
diff --git a/Dockerfile b/Dockerfile
index 8cf73d0b9..2303dbfab 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -75,7 +75,6 @@ RUN --mount=type=bind,source=.,target=/work/src/multiplier \
     -DCMAKE_C_COMPILER="$(which clang-${CLANG_VERSION})" \
     -DCMAKE_CXX_COMPILER="$(which clang++-${CLANG_VERSION})" \
     -DLLVM_DIR="${INSTALL_DIR}/lib/cmake/llvm" \
-    -DMLIR_DIR="${INSTALL_DIR}/lib/cmake/mlir" \
     -DClang_DIR="${INSTALL_DIR}/lib/cmake/clang" \
     -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=TRUE \
     -DMX_USE_VENDORED_CLANG=OFF \
diff --git a/bin/Bootstrap/CMakeLists.txt b/bin/Bootstrap/CMakeLists.txt
index ab29c4de3..459bf24d3 100644
--- a/bin/Bootstrap/CMakeLists.txt
+++ b/bin/Bootstrap/CMakeLists.txt
@@ -8,7 +8,6 @@
 set(exe_name "mx-bootstrap-pasta")
 
 option(MX_BOOTSTRAP_PASTA "Set to ON to bootstrap PASTA" ON)
-option(MX_BOOTSTRAP_VAST "Set to ON to bootstrap VAST" ON)
 
 add_library("mx-bootstrap" STATIC
   "Bootstrap.cpp"
@@ -80,32 +79,3 @@ if(MX_BOOTSTRAP_PASTA)
       "Bootstrapping Multiplier"
   )
 endif(MX_BOOTSTRAP_PASTA)
-
-if(MX_BOOTSTRAP_VAST)
-  add_executable("mx-bootstrap-vast"
-    "VAST.cpp"
-    "${PROJECT_SOURCE_DIR}/bin/Index/Entity.h"
-  )
-  
-  target_link_libraries("mx-bootstrap-vast"
-    PRIVATE
-      "mx-bootstrap"
-
-      ${MLIR_LIBS}
-      ${VAST_LIBS}
-  )
-  
-  # Run `mx-bootstrap-vast` to auto-generate the files.
-  add_custom_command(
-    TARGET
-      "mx-bootstrap-vast"
-    POST_BUILD
-    COMMAND
-      "mx-bootstrap-vast"
-      "${install_include_dir}"
-      "${dependencies_include_dir}"
-      "${LLVM_INCLUDE_DIR}"
-    COMMENT
-      "Bootstrapping Multiplier"
-  )
-endif(MX_BOOTSTRAP_VAST)
diff --git a/bin/Bootstrap/PASTA.cpp b/bin/Bootstrap/PASTA.cpp
index 3d4743f02..809215754 100644
--- a/bin/Bootstrap/PASTA.cpp
+++ b/bin/Bootstrap/PASTA.cpp
@@ -2454,8 +2454,7 @@ MethodListPtr CodeGenerator::RunOnClass(
         << FriendOf(class_os, class_name, "TokenContext")
         << FriendOf(class_os, class_name, "Type")
         << FriendOf(class_os, class_name, class_name + "Impl")
-        << "  friend class ir::Operation;\n"
-        << "  friend class ir::Value;\n\n"
+        << "\n\n"
         << "  std::shared_ptr<const " << class_name << "Impl> impl;\n";
 
     if (class_name == base_name) {
@@ -2837,35 +2836,25 @@ MethodListPtr CodeGenerator::RunOnClass(
 
   if (is_declaration || is_statement) {
     class_os
-        << "  static std::optional<" << class_name
-        << "> from(const ir::Operation &op);\n"
-        << "  static gap::generator<std::pair<" << class_name
-        << ", ir::Operation>> in(const Compilation &tu);\n";
+        << "  static gap::generator<" << class_name
+        << "> in(const Compilation &tu);\n";
 
     // The base class methods are all manually implemented.
     if (class_name == base_name) {
       class_os
-          << "  static gap::generator<std::pair<" << class_name
-          << ", ir::Operation>> in(const Compilation &tu, std::span<const "
+          << "  static gap::generator<" << class_name
+          << "> in(const Compilation &tu, std::span<const "
           << base_name << "Kind> kinds);\n\n";
     
     } else {
       lib_cpp_os
-          << "std::optional<" << class_name
-          << "> " << class_name << "::from(const ir::Operation &op) {\n"
-          << "  if (auto val = " << base_name << "::from(op)) {\n"
-          << "    return from_base(val.value());\n"
-          << "  }\n"
-          << "  return std::nullopt;\n"
-          << "}\n\n"
-          << "gap::generator<std::pair<" << class_name << ", ir::Operation>> "
+          << "gap::generator<" << class_name << "> "
           << class_name << "::in(const Compilation &tu) {\n"
-          << "  for (std::pair<" << base_name << ", ir::Operation> res : "
+          << "  for (" << base_name << " res : "
           << base_name << "::in(tu, k" << class_name
           << "DerivedKinds)) {\n"
-          << "    if (auto val = from_base(res.first)) {\n"
-          << "      co_yield std::pair<" << class_name << ", ir::Operation>("
-          << "std::move(val.value()), std::move(res.second));\n"
+          << "    if (auto val = from_base(res)) {\n"
+          << "      co_yield val.value();\n"
           << "    }\n"
           << "  }\n"
           << "}\n\n";
@@ -3939,10 +3928,6 @@ MethodListPtr CodeGenerator::RunOnClass(
   }
 
   os
-      << "namespace ir {\n"
-      << "class Operation;\n"
-      << "class Value;\n"
-      << "}  // namespace ir\n\n"
       << "#if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)\n"
       << class_os.str()
       << late_class_os.str()
@@ -4335,10 +4320,6 @@ void CodeGenerator::RunOnClassHierarchies(void) {
       }
     }
 
-    if (gDeclNames.count(name) || gStmtNames.count(name)) {
-      fs << "\n#include <multiplier/IR/HighLevel/Operation.h>\n"; 
-    }
-
     if (!is_enum) {
       fs << "\n#include \"../EntityProvider.h\"\n";
     }
diff --git a/bin/Bootstrap/Python.cpp b/bin/Bootstrap/Python.cpp
index aa666705d..6054fb604 100644
--- a/bin/Bootstrap/Python.cpp
+++ b/bin/Bootstrap/Python.cpp
@@ -1,7 +1,6 @@
 
 #include <multiplier/AST.h>
 #include <multiplier/Frontend.h>
-#include <multiplier/IR.h>
 #include <multiplier/Index.h>
 
 #include <multiplier/Re2.h>
diff --git a/bin/Bootstrap/PythonBindings.py b/bin/Bootstrap/PythonBindings.py
index bf77536b0..8f065d6f7 100644
--- a/bin/Bootstrap/PythonBindings.py
+++ b/bin/Bootstrap/PythonBindings.py
@@ -298,7 +298,6 @@ class UserToken;
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -496,12 +495,6 @@ class UserToken;
 }}  // namespace
 """
 
-
-IR_TYPE_HASH = """[] (BorrowedPyObject *obj) -> Py_hash_t {{
-    return static_cast<Py_hash_t>(reinterpret_cast<uintptr_t>(T_cast(obj)->underlying_{}()));
-  }}"""
-
-
 TYPE_HASH = """[] (BorrowedPyObject *obj) -> Py_hash_t {
     return static_cast<Py_hash_t>(EntityId(T_cast(obj)->id()).Pack());
   }"""
@@ -926,7 +919,6 @@ class UserToken;
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 #include <multiplier/Reference.h>
 
@@ -1331,18 +1323,6 @@ def _strip_optional_const_ref(schema: Schema) -> Schema:
     return schema
 
 
-_IR_BASE_CLASSES = ("Operation", "Region", "Block", "Type",
-                    "Attribute", "Value", "Operand")
-
-
-def _is_mlir_base_class(schema: ClassSchema) -> bool:
-  if schema.name not in _IR_BASE_CLASSES:
-    return False
-
-  return schema.namespaces and len(schema.namespaces) and \
-         schema.namespaces[-1] == 'ir'
-
-
 def wrap_class(schema: ClassSchema,
                offsets: Dict[ClassSchema, Tuple[int, int]],
                children: Dict[ClassSchema, List[ClassSchema]],
@@ -1413,9 +1393,6 @@ def wrap_class(schema: ClassSchema,
     if _is_id_method(id_method):
       type_hash = TYPE_HASH
 
-  elif _is_mlir_base_class(schema):
-    type_hash = IR_TYPE_HASH.format(schema.name.lower())
-
   elif schema.name == "TokenTreeNode":
     type_hash = HASH_CODE_TYPE_HASH
 
diff --git a/bin/Bootstrap/VAST.cpp b/bin/Bootstrap/VAST.cpp
deleted file mode 100644
index 94af64cce..000000000
--- a/bin/Bootstrap/VAST.cpp
+++ /dev/null
@@ -1,2336 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#ifdef MX_IN_BOOTSTRAP
-
-#include <mlir/IR/BuiltinOps.h>
-#include <mlir/IR/BuiltinTypes.h>
-#include <mlir/IR/BuiltinAttributes.h>
-#include <mlir/IR/SymbolTable.h>
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <mlir/Dialect/MemRef/IR/MemRef.h>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/ABI/ABIDialect.hpp>
-#include <vast/Dialect/ABI/ABIOps.hpp>
-#include <vast/Dialect/Core/CoreDialect.hpp>
-#include <vast/Dialect/Core/CoreOps.hpp>
-#include <vast/Dialect/Core/CoreTypes.hpp>
-#include <vast/Dialect/HighLevel/HighLevelDialect.hpp>
-#include <vast/Dialect/HighLevel/HighLevelOps.hpp>
-#include <vast/Dialect/HighLevel/HighLevelTypes.hpp>
-#include <vast/Dialect/LowLevel/LowLevelDialect.hpp>
-#include <vast/Dialect/LowLevel/LowLevelOps.hpp>
-#include <vast/Dialect/Meta/MetaDialect.hpp>
-#include <vast/Dialect/Meta/MetaAttributes.hpp>
-#include <vast/Dialect/Meta/MetaTypes.hpp>
-#include <vast/Dialect/Unsupported/UnsupportedDialect.hpp>
-#include <vast/Dialect/Unsupported/UnsupportedOps.hpp>
-#include <vast/Dialect/Unsupported/UnsupportedTypes.hpp>
-#include <vast/Util/DataLayout.hpp>
-
-#else
-
-#include <pasta/AST/AST.h>
-#include <pasta/AST/Attr.h>
-#include <pasta/AST/Decl.h>
-#include <pasta/AST/Forward.h>
-#include <pasta/AST/Macro.h>
-#include <pasta/AST/Printer.h>
-#include <pasta/AST/Stmt.h>
-#include <pasta/AST/Type.h>
-#include <pasta/Compile/Command.h>
-#include <pasta/Compile/Compiler.h>
-#include <pasta/Compile/Job.h>
-#include <pasta/Util/ArgumentVector.h>
-#include <pasta/Util/FileSystem.h>
-#include <pasta/Util/Init.h>
-
-#include <cctype>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <map>
-#include <set>
-#include <sstream>
-#include <string>
-#include <string_view>
-#include <vector>
-
-#include "Bootstrap.h"
-
-struct Op {
-  std::string root_ns;
-  std::string ns;
-  std::string_view op_name;
-  std::string name;
-  pasta::CXXRecordDecl cls;
-  std::vector<pasta::CXXMethodDecl> methods;
-  std::vector<std::string_view> attributes;
-
-  inline Op(const pasta::CXXRecordDecl &cls_)
-      : cls(cls_) {}
-};
-
-struct Type {
-  std::string root_ns;
-  std::string ns;
-  std::string_view mnemonic;
-  std::string name;
-  pasta::CXXRecordDecl cls;
-  std::vector<pasta::CXXMethodDecl> methods;
-  std::vector<pasta::CXXMethodDecl> datalayout_methods;
-
-  inline Type(const pasta::CXXRecordDecl &cls_)
-      : cls(cls_) {}
-};
-
-struct Attr {
-  std::string root_ns;
-  std::string ns;
-  std::string_view mnemonic;
-  std::string name;
-  pasta::CXXRecordDecl cls;
-  std::vector<pasta::CXXMethodDecl> methods;
-
-  inline Attr(const pasta::CXXRecordDecl &cls_)
-      : cls(cls_) {}
-};
-
-class CodeGenerator {
- private:
-
-  std::vector<Op> ops;
-  std::vector<Type> types;
-  std::vector<Attr> attrs;
-  std::set<const void *> seen_decls;
-
-  std::map<std::string, std::string> included_by;
-  std::map<std::string, std::map<uint64_t, std::string>> include_paths;
-
-  void RunOnOpClass(const std::string &root_ns, const std::string &ns,
-                    const pasta::CXXRecordDecl &cls,
-                    std::vector<pasta::CXXMethodDecl> methods,
-                    std::vector<std::string_view> attributes,
-                    std::string_view op_name);
-
-  void RunOnAttrClass(const std::string &root_ns, const std::string &ns,
-                      const pasta::CXXRecordDecl &cls,
-                      std::vector<pasta::CXXMethodDecl> methods,
-                      std::string_view op_name);
-
-  void RunOnTypeClass(const std::string &root_ns, const std::string &ns,
-                      const pasta::CXXRecordDecl &cls,
-                      std::vector<pasta::CXXMethodDecl> methods,
-                      std::vector<pasta::CXXMethodDecl> dl_methods,
-                      std::string_view op_name);
-
-  void RunOnClasses(const std::string &root_ns, const std::string &ns,
-                    std::vector<pasta::CXXRecordDecl> classes);
-  void RunOnEnums(const std::string &root_ns, const std::string &ns,
-                  std::vector<pasta::EnumDecl> enums);
-  void RunOnNamespace(const pasta::NamespaceDecl &root_ns,
-                      pasta::NamespaceDecl ns);
-
-  void FillIncludePathsFor(const pasta::CXXRecordDecl &cls);
-  void RunOnTranslationUnit(pasta::TranslationUnitDecl tu);
-  void FindIncludePaths(pasta::MacroRange macros, pasta::File main_file);
-  std::string TopIncludePath(std::string path);
- public:
-  CodeGenerator(char *argv[]);
-  void RunOnAST(pasta::AST ast);
-
-  void Summarize(void);
-  void RunOnOps(void);
-  void RunOnTypes(void);
-  void RunOnAttrs(void);
-};
-
-static const std::map<std::string, std::string> kMethodRenames = {
-  {"lhs", "left"},
-  {"rhs", "right"},
-  {"src", "source"},
-  {"dst", "destination"},
-  {"expr", "expression"},
-  {"val", "value"},
-  {"arg", "argument"},
-  {"args", "arguments"},
-  {"cond_region", "condition_region"},
-  {"decl", "declaration"},
-  {"sym_name", "name"},
-  {"sym_visibility", "visibility"},
-  {"subexpr", "nested_expression"},
-  {"asm_string", "assembly"},
-  {"is_expr_predicate", "is_expression_predicate"},
-  {"init", "initializer"},
-  {"res", "result"},
-  {"assert", "assertion"},
-  {"substmt", "nested_statement"},
-  {"arg_list", "argument_list"},
-  {"is_local_var_decl", "is_local_variable_declaration"},
-  {"is_static_local", "is_static_local_variable_declaration"},
-  {"is_file_var_decl", "is_file_variable_declaration"},
-  {"int", "integer_value"},
-  {"s_int", "signed_integer_value"},
-  {"u_int", "unsigned_integer_value"},
-};
-
-static std::string MethodName(const std::string &name) {
-  std::string new_name = Capitalize(name);
-
-  if (new_name.starts_with("Get") && !new_name.starts_with("Gets")) {
-    new_name = new_name.substr(3u);
-  }
-
-  new_name = CapitalCaseToSnakeCase(new_name);
-  auto name_it = kMethodRenames.find(new_name);
-  if (name_it != kMethodRenames.end()) {
-    return name_it->second;
-  }
-
-  return new_name;
-}
-
-static std::optional<pasta::Decl> GetDefinition(const pasta::NamedDecl &decl) {
-  if (auto r = pasta::RecordDecl::From(decl)) {
-    if (auto d = r->Definition()) {
-      return d.value();
-    }
-    return decl;
-  } else if (auto f = pasta::FunctionDecl::From(decl)) {
-    if (auto d = f->Definition()) {
-      return d.value();
-    }
-    return decl;
-  } else if (pasta::TypedefNameDecl::From(decl)) {
-    return decl;
-  }
-
-  return std::nullopt;
-}
-
-//// MLIR's TableGen produces `.h.inc` files, and often the `.h` actually includes
-//// the `.h
-//static std::filesystem::path FixupPath(std::filesystem::path p) {
-//  if (p.extension() != ".inc") {
-//    return p;
-//  }
-//
-//  std::filesystem::path np = p;
-//  np = np.replace_extension();
-//
-//  if (np.extension() == ".h" && std::filesystem::exists(np)) {
-//    return np;
-//  }
-//
-//  return p;
-//}
-
-static void IsRegionFalse(std::ostream &os, const char *val_name) {
-  os << val_name << ".empty()";
-}
-
-static void GetRegionValue(std::ostream &os, const char *val_name) {
-  os << val_name;
-}
-
-using IsFalseFunc = void(std::ostream &, const char *);
-using GetOptValueFunc = void(std::ostream &, const char *);
-
-struct OptionalMethod {
-  std::string_view op_name;
-  std::string_view method_name;
-  IsFalseFunc *is_false;
-  GetOptValueFunc *get_value;
-};
-
-static const OptionalMethod kOptionalMethods[] = {
-  {"ForOp", "cond_region", IsRegionFalse, GetRegionValue},
-  {"ForOp", "incr_region", IsRegionFalse, GetRegionValue},
-  {"ForOp", "body_region", IsRegionFalse, GetRegionValue},
-  {"FuncOp", "body", IsRegionFalse, GetRegionValue},
-  {"IfOp", "else_region", IsRegionFalse, GetRegionValue},
-  {"VarDeclOp", "initializer", IsRegionFalse, GetRegionValue},
-  {"VarDeclOp", "allocation_size", IsRegionFalse, GetRegionValue},
-  {"CaseOp", "body", IsRegionFalse, GetRegionValue},
-  {"DefaultOp", "body", IsRegionFalse, GetRegionValue},
-  {"BinaryCondOp", "common_region", IsRegionFalse, GetRegionValue},
-};
-
-static std::pair<IsFalseFunc *, GetOptValueFunc *>
-IsOptionalReturn(std::string_view op_name, std::string_view meth_name) {
-  for (auto [on, mn, is_false, get_value] : kOptionalMethods) {
-    if (on == op_name && mn == meth_name) {
-      return {is_false, get_value};
-    }
-  }
-  return {nullptr, nullptr};
-}
-
-// Calculate a relative path given an absolute path. We want relative paths
-// located inside of Clang, LLVM, MLIR, or VAST.
-static std::string RelativePath(std::filesystem::path file_path) {
-  std::filesystem::path path;
-  int seen_include = 0;
-  for (auto part : file_path) {
-    if (seen_include == 1) {
-      if (part != "mlir" && part != "clang" && part != "llvm" && part != "vast") {
-        return {};
-      }
-      path = part;
-      ++seen_include;
-    } else if (seen_include) {
-      path /= part;
-    } else if (part == "include") {
-      seen_include = 1;
-    }
-  }
-
-  if (seen_include < 2) {
-    return {};
-  }
-
-  return path.generic_string();
-//  return FixupPath(path).generic_string();
-}
-
-static std::string IncludePathFor(const pasta::NamedDecl &cls_) {
-  auto def = GetDefinition(cls_);
-  if (!def) {
-    return {};
-  }
-
-  pasta::Decl cls = std::move(def.value());
-  for (pasta::Token tok : cls.Tokens()) {
-    std::optional<pasta::FileToken> ftok = tok.FileLocation();
-    if (!ftok) {
-      continue;
-    }
-
-    return RelativePath(pasta::File::Containing(ftok.value()).Path());
-  }
-
-  return {};
-}
-
-void CodeGenerator::FillIncludePathsFor(const pasta::CXXRecordDecl &cls) {
-
-  std::set<std::string> seen;
-
-  std::string cls_path = IncludePathFor(cls);
-  if (cls_path.empty()) {
-    return;
-  }
-
-  std::map<uint64_t, std::string> &ordered_paths
-      = include_paths[cls_path];
-
-  cls_path = TopIncludePath(cls_path);
-  seen.insert(cls_path);
-
-  ordered_paths.emplace(cls.Token().Index(), cls_path);
-
-  auto pt = pasta::PrintedTokenRange::Create(cls);
-
-  for (pasta::PrintedToken tok : pt) {
-    for (std::optional<pasta::TokenContext> tc = tok.Context();
-         tc; tc = tc->Parent()) {
-      std::optional<pasta::Decl> tcd = pasta::Decl::From(tc.value());
-      if (!tcd) {
-        continue;
-      }
-
-      std::optional<pasta::NamedDecl> rd = pasta::NamedDecl::From(tcd.value());
-      if (!rd) {
-        continue;
-      }
-
-      std::string rd_path = TopIncludePath(IncludePathFor(rd.value()));
-      if (!rd_path.empty() && seen.emplace(rd_path).second) {
-        ordered_paths.emplace(rd->Token().Index(), rd_path);
-      }
-    }
-  }
-}
-
-//static std::string ClassNameToOpName(std::string name) {
-//  if (name.ends_with("Op")) {
-//    return name;
-//  } else if (name == "vscale") {
-//    return "VScaleOp";
-//  } else if (name.starts_with("masked_") || name.starts_with("vector_")) {
-//    auto uc = true;
-//    std::string ret;
-//    for (char ch : name) {
-//      if (ch == '_') {
-//        uc = true;
-//        continue;
-//      } else if (uc) {
-//        uc = false;
-//        ret.push_back(static_cast<char>(std::toupper(ch)));
-//      } else {
-//        ret.push_back(ch);
-//      }
-//    }
-//    ret.push_back('O');
-//    ret.push_back('p');
-//    return ret;
-//  } else {
-//    name.push_back('O');
-//    name.push_back('p');
-//    return name;
-//  }
-//}
-
-static const std::map<std::string, std::string> kOpNameRenames = {
-  {"Fshl", "FShlOp"},
-  {"Fshr", "FShrOp"},
-  {"GEP", "GetElementPtrOp"},
-  {"Fshr", "FShrOp"},
-  {"Llrint", "RoundAndCastToLongLongOp"},
-  {"Llround", "RoundAndCastToNearestLongLongOp"},
-  {"Lrint", "RoundAndCastToLongOp"},
-  {"Lround", "RoundAndCastToNearestLongOp"},
-  {"MaskedCompressstore", "MaskedCompressStoreOp"},
-  {"MaskedExpandload", "MaskedExpandLoadOp"},
-  {"Nearbyint", "RoundToNearbyIntOp"},
-  {"Rint", "RoundToIntOp"},
-  {"Round", "RoundToNearestOp"},
-  {"RoundEven", "RoundToNearestEvenOp"},
-  {"Pow", "FPowOp"},
-  {"Powl", "SPowOp"},
-  {"SSHLSat", "SShlSatOp"},
-  {"ThreadlocalAddress", "ThreadLocalAddressOp"},
-  {"USHLSat", "UShlSatOp"},
-  {"VectorReduceFadd", "VectorReduceFAddOp"},
-  {"VectorReduceFmul", "VectorReduceFMulOp"},
-  {"VectorReduceSmax", "VectorReduceSMaxOp"},
-  {"VectorReduceSmin", "VectorReduceSMinOp"},
-  {"VectorReduceUmax", "VectorReduceUMaxOp"},
-  {"VectorReduceUmin", "VectorReduceUMinOp"},
-  {"VectorReduceFmax", "VectorReduceFMaxOp"},
-  {"VectorReduceFmin", "VectorReduceFMinOp"},
-  {"VectorReduceFmaximum", "VectorReduceFMaximumOp"},
-  {"VectorReduceFminimum", "VectorReduceFMinimumOp"},
-  {"Vscale", "VScaleOp"},
-  {"DmaStart", "DMAStartOp"},
-  {"DmaWait", "DMAWaitOp"},
-};
-
-static std::string FinalizeOpNameToClassCase(std::string ret) {
-  if (auto new_ret = kOpNameRenames.find(ret);
-      new_ret != kOpNameRenames.end()) {
-    return new_ret->second;
-  }
-
-  return ret + "Op";
-}
-
-static std::string OpNameToClassCase(std::string_view name) {
-  if (name.ends_with("Op")) {
-    name.remove_suffix(2);
-  }
-
-  if (name.starts_with("llvm") || name.starts_with("LLVM")) {
-    name.remove_prefix(4);
-  }
-
-  if (name.starts_with('_')) {
-    name.remove_prefix(1);
-  }
-
-  if (std::isupper(name[0])) {
-    return FinalizeOpNameToClassCase(std::string(name.begin(), name.end()));
-  }
-
-  return FinalizeOpNameToClassCase(Capitalize(SnakeCaseToCamelCase(name)));
-}
-
-static std::string OpNameToEnumCase(std::string_view name) {
-  std::string ret;
-  for (char ch : name) {
-    if (ch == '"') {
-      continue;
-    } else if (ch == '.') {
-      ret.push_back('_');
-    } else {
-      ret.push_back(static_cast<char>(std::toupper(ch)));
-    }
-  }
-  return ret;
-}
-
-static std::string OpNameToSnakeCase(std::string_view name) {
-  std::string ret;
-  for (char ch : name) {
-    if (ch == '"') {
-      continue;
-    } else if (ch == '.') {
-      ret.push_back('_');
-    } else {
-      ret.push_back(static_cast<char>(std::tolower(ch)));
-    }
-  }
-  return ret;
-}
-
-// Try to find the MLIR operation name.
-static std::string_view FindName(const pasta::CXXMethodDecl &decl) {
-  for (pasta::Token tok : decl.Body()->Tokens()) {
-    if (tok.Kind() == pasta::TokenKind::kStringLiteral) {
-      return tok.Data();
-    }
-  }
-  return {};
-}
-
-// Try to find the MLIR attribute names.
-static std::vector<std::string_view> FindNames(
-    const pasta::CXXMethodDecl &decl) {
-  std::vector<std::string_view> names;
-  for (pasta::Token tok : decl.Body()->Tokens()) {
-    if (tok.Kind() == pasta::TokenKind::kStringLiteral) {
-      names.emplace_back(tok.Data());
-    }
-  }
-  return names;
-}
-
-static std::string TokensToString(const pasta::PrintedTokenRange &toks) {
-  std::stringstream ss;
-  for (pasta::PrintedToken tok : toks) {
-    ss << tok.Data();
-  }
-  return ss.str();
-}
-
-struct Dialect {
-  std::string_view name;
-  std::filesystem::path our_dir_name;
-  std::string_view our_ns_name;
-
-  std::string_view ns_key;
-  std::string_view root_ns;
-  std::string_view ns;
-  std::vector<Op *> ops;
-  std::vector<Type *> types;
-  std::vector<Attr *> attrs;
-};
-
-static Dialect gDialects[] = {
-  // MLIR.
-  {"Builtin", "Builtin", "builtin", "mlir", "", "mlir", {}, {}, {}},
-  {"LLVMIR", "LLVM", "llvm", "mlir::LLVM", "mlir", "LLVM", {}, {}, {}},
-  {"MemRef", "MemRef", "memref", "mlir::memref", "mlir", "memref", {}, {}, {}},
-  
-  // TODO(pag): Including this seems to replicate `ModuleOp` and `UnrealizedConversionCastOp`.
-  // {"DLTI", "MLIR/DLTI", "dlti", "mlir", "", "mlir", {}, {}, {}},
-
-  // VAST.
-  {"ABI", "ABI", "abi", "vast::abi", "vast", "abi", {}, {}, {}},
-  {"LowLevel", "LowLevel", "ll", "vast::ll", "vast", "ll", {}, {}, {}},
-  {"HighLevel", "HighLevel", "hl", "vast::hl", "vast", "hl", {}, {}, {}},
-  {"Core", "Core", "core", "vast::core", "vast", "core", {}, {}, {}},
-  {"Meta", "Meta", "meta", "vast::meta", "vast", "meta", {}, {}, {}},
-  {"Unsupported", "Unsupported", "unsup", "vast::unsup", "vast", "unsup", {}, {}, {}},
-};
-
-class TypeWrapper {
- public:
-  virtual ~TypeWrapper(void) {}
-  virtual void ReturnType(std::ostream &, const pasta::CXXMethodDecl &) = 0;
-  virtual std::string_view MethodRefKind(void) {
-    return {};
-  }
-  virtual std::string_view CallMethod(std::ostream &, const pasta::CXXMethodDecl &,
-                                      const std::string &) {
-    return {};
-  }
-  virtual void Implementation(std::ostream &, const pasta::CXXMethodDecl &,
-                              const std::string &indent,
-                              std::string_view val) = 0;
-};
-
-class IdentityWrapper final : public TypeWrapper {
- private:
-  std::string_view type_name;
-
- public:
-  virtual ~IdentityWrapper(void) = default;
-  explicit IdentityWrapper(std::string_view type_name_)
-      : type_name(type_name_) {}
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &) final {
-    os << type_name;
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "auto val = underlying_repr()." << m.Name() << "();\n";
-    return "val";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &,
-                      const std::string &indent, std::string_view val) final {
-    os << indent << "return " << val << ";\n";
-  }
-};
-
-class OptionalTypeWrapper final : public TypeWrapper {
- private:
-  TypeWrapper *next;
-
- public:
-  virtual ~OptionalTypeWrapper(void) = default;
-
-  explicit OptionalTypeWrapper(TypeWrapper *next_)
-      : next(next_) {}
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &m) final {
-    os << "std::optional<";
-    next->ReturnType(os, m);
-    os << ">";
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "auto opt_val = underlying_repr()." << m.Name() << "();\n"
-       << indent << "if (!opt_val) {\n"
-       << indent << "  return std::nullopt;\n"
-       << indent << "}\n"
-       << indent << "auto &val = opt_val.value();\n";
-    return "val";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &m,
-                      const std::string &indent, std::string_view val) final {
-    next->Implementation(os, m, indent, val);
-  }
-};
-
-class FalsyOptionalTypeWrapper final : public TypeWrapper {
- private:
-  TypeWrapper * const next;
-  IsFalseFunc * const is_false;
-  GetOptValueFunc * const get_value;
-
- public:
-  virtual ~FalsyOptionalTypeWrapper(void) = default;
-
-  explicit FalsyOptionalTypeWrapper(TypeWrapper *next_,
-                                    IsFalseFunc *is_false_,
-                                    GetOptValueFunc *get_value_)
-      : next(next_),
-        is_false(is_false_),
-        get_value(get_value_) {}
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &m) final {
-    os << "std::optional<";
-    next->ReturnType(os, m);
-    os << ">";
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "decltype(auto) opt_val = underlying_repr()." << m.Name() << "();\n"
-       << indent << "if (";
-
-    is_false(os, "opt_val");
-
-    os << ") {\n"
-       << indent << "  return std::nullopt;\n"
-       << indent << "}\n"
-       << indent << "auto &val = ";
-
-    get_value(os, "opt_val");
-
-    os << ";\n";
-
-    return "val";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &m,
-                      const std::string &indent, std::string_view val) final {
-    next->Implementation(os, m, indent, val);
-  }
-};
-
-class StringRefWrapper final : public TypeWrapper {
- public:
-  virtual ~StringRefWrapper(void) = default;
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &) final {
-    os << "std::string_view";
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "auto val = underlying_repr()." << m.Name() << "();\n";
-    return "val";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &,
-                      const std::string &indent, std::string_view val) final {
-    os
-       << indent << "if (auto size = " << val << ".size()) {\n"
-       << indent << "  return std::string_view(" << val << ".data(), size);\n"
-       << indent << "} else {\n"
-       << indent << "  return {};\n"
-       << indent << "}\n";
-  }
-};
-
-class ValueWrapper final : public TypeWrapper {
- public:
-  virtual ~ValueWrapper(void) = default;
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &m) final {
-    if (m.Name().ends_with("result")) {
-      os << "::mx::ir::Result";
-    } else {
-      os << "::mx::ir::Value";
-    }
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "auto val = underlying_repr()." << m.Name() << "();\n";
-    return "val";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &m,
-                      const std::string &indent, std::string_view val) final {
-    if (m.Name().ends_with("result")) {
-      os << indent << "return ::mx::ir::Result(module_, " << val
-         << ".getAsOpaquePointer());\n";
-    } else {
-      os << indent << "return ::mx::ir::Value(module_, " << val
-         << ".getAsOpaquePointer());\n";
-    }
-  }
-};
-
-class RegionWrapper final : public TypeWrapper {
- public:
-  virtual ~RegionWrapper(void) = default;
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &) final {
-    os << "::mx::ir::Region";
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "auto &val = underlying_repr()." << m.Name() << "();\n";
-    return "val";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &m,
-                      const std::string &indent, std::string_view val) final {
-    os << indent << "return ::mx::ir::Region(module_, " << val << ");\n";
-  }
-};
-
-class BlockWrapper final : public TypeWrapper {
- public:
-  virtual ~BlockWrapper(void) = default;
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &) final {
-    os << "::mx::ir::Block";
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "auto &val = underlying_repr()." << m.Name() << "();\n";
-    return "val";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &,
-                      const std::string &indent, std::string_view val) final {
-    os << indent << "return ::mx::ir::Block(module_, "<< val << ");\n";
-  }
-};
-
-class ValueGeneratorWrapper final : public TypeWrapper {
- private:
-  std::string_view type_name;
-
- public:
-  virtual ~ValueGeneratorWrapper(void) = default;
-  explicit ValueGeneratorWrapper(std::string_view type_name_)
-      : type_name(type_name_) {}
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &) final {
-    os << "gap::generator<" << type_name << ">";
-  }
-
-  virtual std::string_view MethodRefKind(void) final {
-    return " &";
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "auto range = underlying_repr()." << m.Name() << "();\n";
-    return "range";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &m,
-                      const std::string &indent, std::string_view val) final {
-    os << indent << "for (auto val : " << val << ") {\n"
-       << indent << "  co_yield " << type_name
-       << "(module_, val.getAsOpaquePointer());\n"
-       << indent << "}\n";
-  }
-};
-
-class RegionGeneratorWrapper final : public TypeWrapper {
- public:
-  virtual ~RegionGeneratorWrapper(void) = default;
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &) final {
-    os << "gap::generator<::mx::ir::Region>";
-  }
-
-  virtual std::string_view MethodRefKind(void) final {
-    return " &";
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "decltype(auto) regions = underlying_repr()." << m.Name() << "();\n";
-    return "regions";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &m,
-                      const std::string &indent, std::string_view val) final {
-    os << indent << "for (auto &region : " << val << ") {\n"
-       << indent << "  co_yield ::mx::ir::Region(module_, &region);\n"
-       << indent << "}\n";
-  }
-};
-
-class TypeTypeWrapper final : public TypeWrapper {
- public:
-  virtual ~TypeTypeWrapper(void) = default;
-  explicit TypeTypeWrapper(void) {}
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &) final {
-    os << "::mx::ir::Type";
-  }
-
-  virtual std::string_view MethodRefKind(void) final {
-    return "";
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "auto mlir_type = underlying_repr()." << m.Name() << "();\n";
-    return "mlir_type";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &m,
-                      const std::string &indent, std::string_view val) final {
-    os << indent << "return ::mx::ir::Type(\n"
-       << indent << "    " << val << ".getContext(),\n"
-       << indent << "    reinterpret_cast<const mlir::TypeStorage *>(\n"
-       << indent << "        " << val << ".getAsOpaquePointer()));\n";
-  }
-};
-
-class TypeGeneratorWrapper final : public TypeWrapper {
- public:
-  virtual ~TypeGeneratorWrapper(void) = default;
-
-  void ReturnType(std::ostream &os, const pasta::CXXMethodDecl &) final {
-    os << "gap::generator<::mx::ir::Type>";
-  }
-
-  virtual std::string_view MethodRefKind(void) final {
-    return " &";
-  }
-
-  std::string_view CallMethod(std::ostream &os, const pasta::CXXMethodDecl &m,
-                              const std::string &indent) {
-    os << indent << "auto range = underlying_repr()." << m.Name() << "();\n";
-    return "range";
-  }
-
-  void Implementation(std::ostream &os, const pasta::CXXMethodDecl &m,
-                      const std::string &indent, std::string_view val) final {
-
-    os << indent << "for (auto el_ty : " << val << ") {\n"
-       << indent << "  co_yield ::mx::ir::Type(\n"
-       << indent << "      el_ty.getContext(),\n"
-       << indent << "      reinterpret_cast<const mlir::TypeStorage *>(\n"
-       << indent << "          el_ty.getAsOpaquePointer()));\n"
-       << indent << "}\n";
-  }
-};
-
-#define IDENTITY_WRAPPER(t) \
-    {#t, new IdentityWrapper(#t)}, \
-    {"std::optional<" #t ">", new OptionalTypeWrapper(new IdentityWrapper(#t))}, \
-    {"::std::optional<" #t ">", new OptionalTypeWrapper(new IdentityWrapper(#t))}
-
-static std::unordered_map<std::string, TypeWrapper *> gReturnType{
-  IDENTITY_WRAPPER(bool),
-  IDENTITY_WRAPPER(char),
-  IDENTITY_WRAPPER(short),
-  IDENTITY_WRAPPER(int),
-  IDENTITY_WRAPPER(long),
-  IDENTITY_WRAPPER(long long),
-  IDENTITY_WRAPPER(unsigned char),
-  IDENTITY_WRAPPER(unsigned short),
-  IDENTITY_WRAPPER(unsigned int),
-  IDENTITY_WRAPPER(unsigned),
-  IDENTITY_WRAPPER(unsigned long),
-  IDENTITY_WRAPPER(unsigned long long),
-  IDENTITY_WRAPPER(float),
-  IDENTITY_WRAPPER(double),
-  IDENTITY_WRAPPER(int8_t),
-  IDENTITY_WRAPPER(int16_t),
-  IDENTITY_WRAPPER(int32_t),
-  IDENTITY_WRAPPER(int64_t),
-  IDENTITY_WRAPPER(uint8_t),
-  IDENTITY_WRAPPER(uint16_t),
-  IDENTITY_WRAPPER(uint32_t),
-  IDENTITY_WRAPPER(uint64_t),
-  IDENTITY_WRAPPER(size_t),
-  IDENTITY_WRAPPER(std::size_t),
-  IDENTITY_WRAPPER(std::string),
-  IDENTITY_WRAPPER(std::string_view),
-  {"llvm::StringRef", new StringRefWrapper},
-  {"::llvm::StringRef", new StringRefWrapper},
-  {"std::optional<StringRef>", new OptionalTypeWrapper(new StringRefWrapper)},
-  {"::std::optional<StringRef>", new OptionalTypeWrapper(new StringRefWrapper)},
-  {"::std::optional<::llvm::StringRef>", new OptionalTypeWrapper(new StringRefWrapper)},
-  {"::mlir::Value", new ValueWrapper},
-  {"::mlir::Region&", new RegionWrapper},
-  {"::mlir::Region &", new RegionWrapper},
-  {"::mlir::Block&", new BlockWrapper},
-  {"::mlir::Block &", new BlockWrapper},
-  {"::mlir::Type", new TypeTypeWrapper},
-  {"::mlir::Type", new TypeTypeWrapper},
-  {"::mlir::TypedValue<LabelType>", new ValueWrapper},
-  {"mlir::Value", new ValueWrapper},
-  {"mlir::Region&", new RegionWrapper},
-  {"mlir::Region &", new RegionWrapper},
-  {"mlir::Block&", new BlockWrapper},
-  {"mlir::Block &", new BlockWrapper},
-  {"mlir::Type", new TypeTypeWrapper},
-  {"mlir::Type", new TypeTypeWrapper},
-  {"mlir::TypedValue<LabelType>", new ValueWrapper},
-  {"mlir_type", new TypeTypeWrapper},
-  {"::mlir::mlir::Operation::result_range", new ValueGeneratorWrapper("::mx::ir::Result")},
-  {"::mlir::mlir::Operation::operand_range", new ValueGeneratorWrapper("::mx::ir::Operand")},
-  {"::mlir::Operation::result_range", new ValueGeneratorWrapper("::mx::ir::Result")},
-  {"::mlir::Operation::operand_range", new ValueGeneratorWrapper("::mx::ir::Operand")},
-  {"mlir::Operation::result_range", new ValueGeneratorWrapper("::mx::ir::Result")},
-  {"mlir::Operation::operand_range", new ValueGeneratorWrapper("::mx::ir::Operand")},
-  {"::llvm::ArrayRef<Type>", new TypeGeneratorWrapper},
-  {"llvm::ArrayRef<Type>", new TypeGeneratorWrapper},
-  {"gap::generator<Type>", new TypeGeneratorWrapper},
-  {"::gap::generator<Type>", new TypeGeneratorWrapper},
-  {"llvm::SmallVector<Type, 1>", new TypeGeneratorWrapper},
-  {"llvm::SmallVector<Type, 2>", new TypeGeneratorWrapper},
-  {"llvm::SmallVector<Type, 3>", new TypeGeneratorWrapper},
-  {"llvm::SmallVector<Type, 4>", new TypeGeneratorWrapper},
-  {"llvm::SmallVector<Type, 5>", new TypeGeneratorWrapper},
-  {"llvm::SmallVector<Type, 6>", new TypeGeneratorWrapper},
-  {"llvm::SmallVector<Type, 7>", new TypeGeneratorWrapper},
-  {"llvm::SmallVector<Type, 8>", new TypeGeneratorWrapper},
-  {"::std::optional<Type>", new OptionalTypeWrapper(new TypeTypeWrapper)},
-  {"::vast::core::FunctionType", new TypeTypeWrapper},
-  {"::mlir::MutableArrayRef<Region>", new RegionGeneratorWrapper},
-};
-
-void CodeGenerator::Summarize(void) {
-  for (Dialect &dialect : gDialects) {
-    for (Op &op : ops) {
-      if (op.root_ns == dialect.root_ns && op.ns == dialect.ns) {
-        dialect.ops.push_back(&op);
-      }
-    }
-    for (Type &type : types) {
-      if (type.root_ns == dialect.root_ns && type.ns == dialect.ns) {
-        dialect.types.push_back(&type);
-      }
-    }
-    for (Attr &attr : attrs) {
-      if (attr.root_ns == dialect.root_ns && attr.ns == dialect.ns) {
-        dialect.attrs.push_back(&attr);
-      }
-    }
-  }
-
-  for (Dialect &dialect : gDialects) {
-    for (Op *op : dialect.ops) {
-      FillIncludePathsFor(op->cls);
-    }
-    for (Type *ty : dialect.types) {
-      FillIncludePathsFor(ty->cls);
-    }
-    for (Attr *attr : dialect.attrs) {
-      FillIncludePathsFor(attr->cls);
-    }
-  }
-}
-
-template <typename Ent>
-static void DoMethod(const pasta::CXXMethodDecl &meth,
-                     std::ostream &hpp, std::ostream &cpp,
-                     Ent *ent, std::string_view ent_class_name,
-                     std::set<std::string> &seen) {
-  std::string meth_name = meth.Name();
-  std::string api_name = MethodName(meth_name);
-  if (!seen.emplace(api_name).second) {
-    return;
-  }
-
-  pasta::Type return_type = meth.ReturnType();
-  std::string return_type_str =
-      TokensToString(pasta::PrintedTokenRange::Create(return_type));
-
-  TypeWrapper *ret_wrapper = gReturnType[return_type_str];
-  std::optional<FalsyOptionalTypeWrapper> opt_wrapper;
-
-  if (!ret_wrapper) {
-    hpp << "  //" << return_type_str << " " << api_name
-        << "(void) const;\n";
-    return;
-  }
-
-  // Wrap in optional.
-  auto [is_false, get_value] = IsOptionalReturn(ent_class_name, api_name);
-  if (is_false && get_value) {
-    opt_wrapper.emplace(ret_wrapper, is_false, get_value);
-    ret_wrapper = &(opt_wrapper.value());
-  }
-
-  hpp << "  ";
-  ret_wrapper->ReturnType(hpp, meth);
-  hpp << " " << api_name << "(void) const" << ret_wrapper->MethodRefKind()
-      << ";\n";
-
-  ret_wrapper->ReturnType(cpp, meth);
-  cpp << " " << ent_class_name << "::" << api_name << "(void) const"
-      << ret_wrapper->MethodRefKind() << " {\n";
-  std::string_view val = ret_wrapper->CallMethod(cpp, meth, "  ");
-  ret_wrapper->Implementation(cpp, meth, "  ", val);
-  cpp << "}\n\n";
-}
-
-void CodeGenerator::RunOnOps(void) {
-  // "/Users/pag/Code/multiplier/bin/Bootstrap/VAST.cpp"
-  std::filesystem::path file = __FILE__;
-  std::filesystem::path mx_root = file.parent_path().parent_path().parent_path();
-  std::filesystem::path mx_inc = mx_root / "include" / "multiplier";
-  std::filesystem::path mx_lib = mx_root / "lib";
-
-  std::error_code ec;
-  (void) std::filesystem::create_directory(mx_inc / "IR", ec);
-  (void) std::filesystem::create_directory(mx_lib / "IR", ec);
-
-
-  std::ofstream summary_irhpp(mx_inc / "IR.h");
-  std::ofstream hpp(mx_inc / "IR" / "OperationKind.h");
-  std::ofstream cpp(mx_lib / "IR" / "Operation.h");  // In lib.
-
-  summary_irhpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n"
-      << "#pragma once\n\n"
-      << "#include \"IR/Attribute.h\"\n"
-      << "#include \"IR/AttributeKind.h\"\n"
-      << "#include \"IR/Block.h\"\n"
-      << "#include \"IR/Operation.h\"\n"
-      << "#include \"IR/OperationKind.h\"\n"
-      << "#include \"IR/Region.h\"\n"
-      << "#include \"IR/Type.h\"\n"
-      << "#include \"IR/TypeKind.h\"\n"
-      << "#include \"IR/Value.h\"\n\n";
-
-  hpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n"
-      << "#pragma once\n\n"
-      << "#include \"../Compiler.h\"\n\n"
-      << "namespace mx {\n"
-      << "namespace ir {\n\n"
-      << "enum class OperationKind : unsigned {\n"
-      << "  UNKNOWN,\n";
-
-  auto num_ops = 0u;
-  for (Dialect &dialect : gDialects) {
-
-    (void) std::filesystem::create_directory(mx_inc / "IR" / dialect.our_dir_name.generic_string(), ec);
-    (void) std::filesystem::create_directory(mx_lib / "IR" / dialect.our_dir_name.generic_string(), ec);
-
-    summary_irhpp << "#include \"IR/" << dialect.our_dir_name.generic_string() << "/Dialect.h\"\n";
-
-    std::ofstream dialect_hpp(mx_inc / "IR" / dialect.our_dir_name / "Dialect.h");
-    dialect_hpp
-        << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-        << "//\n"
-        << "// This source code is licensed in accordance with the terms specified in\n"
-        << "// the LICENSE file found in the root directory of this source tree.\n\n"
-        << "// Auto-generated file; do not modify!\n\n"
-        << "#pragma once\n\n";
-
-    if (!dialect.attrs.empty()) {
-      dialect_hpp << "#include \"Attribute.h\"\n";
-    }
-
-    if (!dialect.types.empty()) {
-      dialect_hpp << "#include \"Type.h\"\n";
-    }
-
-    if (!dialect.ops.empty()) {
-      dialect_hpp << "#include \"Operation.h\"\n";
-    }
-
-    for (Op *op : dialect.ops) {
-      auto oname = op->op_name;
-      oname.remove_prefix(1);  // Leading `"`.
-      oname.remove_suffix(1);  // Trailing `"`.
-      hpp << "  " << OpNameToEnumCase(op->op_name) << ",  // "
-          << oname << '\n';
-      ++num_ops;
-    }
-  }
-
-  hpp
-      << "};\n\n"
-      << "}  // namespace ir\n\n"
-      << "inline static const char *EnumerationName(ir::OperationKind) {\n"
-      << "  return \"OperationKind\";\n"
-      << "}\n\n"
-      << "inline static constexpr unsigned NumEnumerators(ir::OperationKind) {\n"
-      << "  return " << (num_ops + 1u  /* +1 for UNKNOWN */) << ";\n"
-      << "}\n\n"
-      << "MX_EXPORT const char *EnumeratorName(ir::OperationKind);\n\n";
-
-  for (Dialect &dialect : gDialects) {
-    hpp
-        << "MX_EXPORT bool Is" << dialect.name << "OperationKind(ir::OperationKind);\n\n";
-  }
-
-  hpp
-      << "}  // namespace mx\n";
-
-  cpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n";
-
-  auto sep = "#define MX_IR_FOR_EACH_MLIR_OP(";
-
-  for (Dialect &dialect : gDialects) {
-    cpp << sep << '_' << dialect.our_ns_name;
-    sep = ", ";
-  }
-
-  cpp << ")";
-
-  for (Dialect &dialect : gDialects) {
-    for (Op *op : dialect.ops) {
-      cpp << " \\\n   _" << dialect.our_ns_name << "(" << op->op_name << ", OperationKind::"
-          << OpNameToEnumCase(op->op_name) << ", " << dialect.ns_key << "::"
-          << op->name << ")";
-    }
-  }
-
-  cpp
-      << "\n\n"
-      << "#define MX_IR_NUM_MLIR_OPS " << num_ops << "\n\n";
-
-  cpp.close();
-  cpp.open(mx_lib / "IR" / "OperationKind.cpp");  // In lib.
-  cpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n"
-      << "#include <multiplier/IR/OperationKind.h>\n\n"
-      << "namespace mx {\n\n"
-      << "const char *EnumeratorName(ir::OperationKind kind) {\n"
-      << "  switch (kind) {\n"
-      << "    default: return \"UNKNOWN\";\n";
-
-  for (Dialect &dialect : gDialects) {
-    for (Op *op : dialect.ops) {
-      std::string ec = OpNameToEnumCase(op->op_name);
-      cpp << "    case ir::OperationKind::" << ec << ": return \"" << ec << "\";\n";
-    }
-  }
-
-  cpp << "  }\n"
-      << "}\n\n";
-
-  for (Dialect &dialect : gDialects) {
-    cpp
-        << "bool Is" << dialect.name << "OperationKind(ir::OperationKind kind) {\n"
-        << "  switch (kind) {\n"
-        << "    default:\n"
-        << "      return false;\n";
-
-    bool any = false;
-    for (Op *op : dialect.ops) {
-      std::string enum_name = OpNameToEnumCase(op->op_name);
-      cpp << "    case mx::ir::OperationKind::" << enum_name << ":\n";
-      any = true;
-    }
-
-    if (any) {
-      cpp
-          << "      return true;\n";
-    }
-    
-    cpp
-        << "  }\n"
-        << "}\n\n";
-  }
-
-  cpp
-      << "}  // namespace mx\n";
-
-  for (Dialect &dialect : gDialects) {
-    if (dialect.ops.empty()) {
-      continue;
-    }
-
-    std::error_code ec;
-    (void) std::filesystem::create_directories(mx_inc / "IR" / dialect.our_dir_name, ec);
-    (void) std::filesystem::create_directories(mx_lib / "IR" / dialect.our_dir_name, ec);
-    
-    hpp.close();
-    hpp.open(mx_inc / "IR" / dialect.our_dir_name / "Operation.h");
-
-    cpp.close();
-    cpp.open(mx_lib / "IR" / dialect.our_dir_name / "Operation.cpp");
-
-    hpp
-        << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-        << "//\n"
-        << "// This source code is licensed in accordance with the terms specified in\n"
-        << "// the LICENSE file found in the root directory of this source tree.\n\n"
-        << "// Auto-generated file; do not modify!\n\n"
-        << "#pragma once\n\n"
-        << "#include \"../Operation.h\"\n\n"
-        << "namespace " << dialect.ns_key << " {\n";
-
-    for (Op *op : dialect.ops) {
-      hpp << "class " << op->name << ";\n";
-    }
-
-    hpp
-        << "}  // namespace " << dialect.ns_key << "\n"
-        << "namespace mx::ir::" << dialect.our_ns_name << " {\n\n"
-        << "class MX_EXPORT Operation : public ::mx::ir::Operation {\n"
-        << " public:\n"
-        << "  static std::optional<Operation> from(const ::mx::ir::Operation &);\n"
-        << "};\n"
-        << "static_assert(sizeof(Operation) == sizeof(::mx::ir::Operation));\n\n";
-
-    if (dialect.our_ns_name == "hl") {
-      hpp
-          << "class MX_EXPORT RefOp : public Operation {\n"
-          << " public:\n"
-          << "  static std::optional<RefOp> from(const ::mx::ir::Operation &);\n"
-          << "  std::optional<Symbol> referenced_symbol(void) const noexcept;\n"
-          << "};\n"
-          << "static_assert(sizeof(RefOp) == sizeof(Operation));\n\n";
-    }
-
-    cpp
-        << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-        << "//\n"
-        << "// This source code is licensed in accordance with the terms specified in\n"
-        << "// the LICENSE file found in the root directory of this source tree.\n\n"
-        << "// Auto-generated file; do not modify!\n\n"
-        << "#include <multiplier/IR/" << dialect.our_dir_name.generic_string()
-        << "/Operation.h>\n\n"
-        << "#include <multiplier/IR/Attribute.h>\n"
-        << "#include <multiplier/IR/Block.h>\n"
-        << "#include <multiplier/IR/Region.h>\n"
-        << "#include <multiplier/IR/Type.h>\n\n"
-        << "#include <ios>\n"
-        << "#include <string>\n\n";
-
-    std::set<std::string> seen;
-    for (Op *op : dialect.ops) {
-      for (const auto &[id, path] : include_paths[IncludePathFor(op->cls)]) {
-        if (seen.emplace(path).second) {
-          cpp << "#include <" << path << ">\n";
-        }
-      }
-    }
-
-    cpp
-        << '\n'
-        << "namespace mx::ir::" << dialect.our_ns_name << " {\n"
-        << "std::optional<Operation> Operation::from(const ::mx::ir::Operation &that) {\n"
-        << "  if (Is" << dialect.name << "OperationKind(that.kind())) {\n"
-        << "    return reinterpret_cast<const Operation &>(that);\n"
-        << "  }\n"
-        << "  return std::nullopt;\n"
-        << "}\n\n";
-
-    for (Op *op : dialect.ops) {
-      std::string op_name = OpNameToClassCase(op->name);
-      std::string snake_name = OpNameToSnakeCase(op->op_name);
-      std::string enum_name = OpNameToEnumCase(op->op_name);
-
-      auto base = "Operation";
-      if (dialect.our_ns_name == "hl") {
-        if (op_name == "GlobalRefOp" ||
-            op_name == "EnumRefOp" ||
-            op_name == "FuncRefOp" ||
-            op_name == "DeclRefOp") {
-          base = "RefOp";
-        }
-      }
-
-      hpp
-          << "class MX_EXPORT " << op_name << " final : public " << base << " {\n"
-          << " public:\n"
-          << "  inline static constexpr OperationKind static_kind(void) {\n"
-          << "    return OperationKind::" << enum_name
-          << ";\n"
-          << "  }\n\n"
-          << "  static std::optional<" << op_name << "> from(const ::mx::ir::Operation &that);\n"
-          << "  static std::optional<" << op_name << "> producing(const ::mx::ir::Value &val);\n\n"
-          << "  ::" << dialect.ns_key
-          << "::" << op->name << " underlying_repr(void) const noexcept;\n\n"
-          << "  // Imported methods:\n";
-      cpp
-          << "std::optional<" << op_name << "> " << op_name
-          << "::from(const ::mx::ir::Operation &that) {\n"
-          << "  if (that.kind() == OperationKind::" << enum_name << ") {\n"
-          << "    return reinterpret_cast<const " << op_name << " &>(that);\n"
-          << "  }\n"
-          << "  return std::nullopt;\n"
-          << "}\n\n"
-          << "std::optional<" << op_name << "> " << op_name
-          << "::producing(const ::mx::ir::Value &that) {\n"
-          << "  if (auto op = ::mx::ir::Operation::producing(that)) {\n"
-          << "    return from(op.value());\n"
-          << "  }\n"
-          << "  return std::nullopt;\n"
-          << "}\n\n"
-          << "::" << dialect.ns_key << "::" << op->name
-          << " " << op_name << "::underlying_repr(void) const noexcept {\n"
-          << "  return ::" << dialect.ns_key << "::" << op->name << "(this->::mx::ir::Operation::op_);\n"
-          << "}\n\n";
-
-      std::set<std::string> seen_methods;
-      for (const pasta::CXXMethodDecl &meth : op->methods) {
-        DoMethod(meth, hpp, cpp, op, op_name, seen_methods);
-      }
-
-      hpp
-          << "};\n"
-          << "static_assert(sizeof(" << op_name << ") == sizeof(Operation));\n\n";
-    }
-
-    hpp
-        << "}  // namespace mx::ir::" << dialect.our_ns_name << "\n";
-
-    cpp
-        << "}  // namespace mx::ir::" << dialect.our_ns_name << "\n";
-  }
-}
-
-static std::string TypeNameToSnakeCase(std::string_view type_name) {
-  if (type_name.ends_with("Type")) {
-    type_name.remove_suffix(4);
-  }
-
-  return CapitalCaseToSnakeCase(type_name);
-}
-
-static std::string TypeNameToEnumCase(const Dialect &dialect,
-                                      std::string_view type_name) {
-  if (type_name.starts_with("LLVM")) {
-    type_name.remove_prefix(4);
-  }
-  if (type_name.starts_with('_')) {
-    type_name.remove_prefix(1);
-  }
-  return OpNameToEnumCase(dialect.our_ns_name) + '_' +
-         OpNameToEnumCase(TypeNameToSnakeCase(type_name));
-}
-
-static std::string TypeNameToClassCase(std::string_view name) {
-  if (name.ends_with("Type")) {
-    name.remove_suffix(4);
-  }
-
-  if (name.starts_with("llvm") || name.starts_with("LLVM")) {
-    name.remove_prefix(4);
-  }
-
-  if (name.starts_with('_')) {
-    name.remove_prefix(1);
-  }
-
-  if (std::isupper(name[0])) {
-    return std::string(name.begin(), name.end()) + "Type";
-  }
-
-  return Capitalize(SnakeCaseToCamelCase(name)) + "Type";
-}
-
-void CodeGenerator::RunOnTypes(void) {
-  // "/Users/pag/Code/multiplier/bin/Bootstrap/VAST.cpp"
-  std::filesystem::path file = __FILE__;
-  std::filesystem::path mx_root = file.parent_path().parent_path().parent_path();
-  std::filesystem::path mx_inc = mx_root / "include" / "multiplier";
-  std::filesystem::path mx_lib = mx_root / "lib";
-
-  std::ofstream hpp(mx_inc / "IR" / "TypeKind.h");
-  std::ofstream cpp(mx_lib / "IR" / "Type.h");  // In lib.
-
-  hpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n"
-      << "#pragma once\n\n"
-      << "#include \"../Compiler.h\"\n\n"
-      << "namespace mx {\n"
-      << "namespace ir {\n\n"
-      << "enum class TypeKind : unsigned {\n"
-      << "  UNKNOWN,\n";
-
-  auto num_types = 0u;
-  for (Dialect &dialect : gDialects) {
-    for (Type *type : dialect.types) {
-      hpp << "  " << TypeNameToEnumCase(dialect, type->name) << ",\n";
-      ++num_types;
-    }
-  }
-
-  hpp
-      << "};\n\n"
-      << "}  // namespace ir\n\n"
-      << "inline static const char *EnumerationName(ir::TypeKind) {\n"
-      << "  return \"TypeKind\";\n"
-      << "}\n\n"
-      << "inline static constexpr unsigned NumEnumerators(ir::TypeKind) {\n"
-      << "  return " << num_types << ";\n"
-      << "}\n\n"
-      << "MX_EXPORT const char *EnumeratorName(ir::TypeKind);\n\n";
-
-  for (Dialect &dialect : gDialects) {
-    hpp
-        << "MX_EXPORT bool Is" << dialect.name << "TypeKind(ir::TypeKind);\n\n";
-  }
-
-  hpp
-      << "}  // namespace mx\n";
-
-  cpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n";
-
-  auto sep = "#define MX_IR_FOR_EACH_MLIR_TYPE(";
-
-  for (Dialect &dialect : gDialects) {
-    cpp << sep << '_' << dialect.our_ns_name;
-    sep = ", ";
-  }
-
-  cpp << ")";
-
-  for (Dialect &dialect : gDialects) {
-    for (Type *type : dialect.types) {
-      cpp << " \\\n   _" << dialect.our_ns_name << "(" << type->name << ", TypeKind::"
-          << TypeNameToEnumCase(dialect, type->name) << ", " << dialect.ns_key << "::"
-          << type->name << ")";
-    }
-  }
-
-  cpp
-      << "\n\n"
-      << "#define MX_IR_NUM_MLIR_TYPES " << num_types << "\n\n";
-
-  cpp.close();
-  cpp.open(mx_lib / "IR" / "TypeKind.cpp");  // In lib.
-  cpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n"
-      << "#include <multiplier/IR/TypeKind.h>\n\n"
-      << "namespace mx {\n\n"
-      << "const char *EnumeratorName(ir::TypeKind kind) {\n"
-      << "  switch (kind) {\n"
-      << "    default: return \"UNKNOWN\";\n";
-
-  for (Dialect &dialect : gDialects) {
-    for (Type *type : dialect.types) {
-      std::string ec = TypeNameToEnumCase(dialect, type->name);
-      cpp << "    case ir::TypeKind::" << ec << ": return \"" << ec << "\";\n";
-    }
-  }
-
-  cpp << "  }\n"
-      << "}\n\n";
-
-  for (Dialect &dialect : gDialects) {
-    cpp
-        << "bool Is" << dialect.name << "TypeKind(ir::TypeKind kind) {\n"
-        << "  switch (kind) {\n"
-        << "    default:\n"
-        << "      return false;\n";
-
-    bool any = false;
-    for (Type *type : dialect.types) {
-      std::string enum_name = TypeNameToEnumCase(dialect, type->name);
-      cpp << "    case mx::ir::TypeKind::" << enum_name << ":\n";
-      any = true;
-    }
-
-    if (any) {
-      cpp
-          << "      return true;\n";
-    }
-    
-    cpp
-        << "  }\n"
-        << "}\n\n";
-  }
-
-  cpp
-      << "}  // namespace mx\n";
-
-  for (const Dialect &dialect : gDialects) {
-    if (dialect.types.empty()) {
-      continue;
-    }
-
-    hpp.close();
-    hpp.open(mx_inc / "IR" / dialect.our_dir_name / "Type.h");
-
-    cpp.close();
-    cpp.open(mx_lib / "IR" / dialect.our_dir_name / "Type.cpp");
-
-    hpp
-        << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-        << "//\n"
-        << "// This source code is licensed in accordance with the terms specified in\n"
-        << "// the LICENSE file found in the root directory of this source tree.\n\n"
-        << "// Auto-generated file; do not modify!\n\n"
-        << "#pragma once\n\n"
-        << "#include \"../Type.h\"\n\n"
-        << "namespace " << dialect.ns_key << " {\n";
-
-    for (Type *type : dialect.types) {
-      hpp << "class " << type->name << ";\n";
-    }
-
-    hpp << "}  // namespace " << dialect.ns_key << "\n"
-        << "namespace mx::ir::" << dialect.our_ns_name << " {\n\n"
-        << "class MX_EXPORT Type : public ::mx::ir::Type {\n"
-        << " public:\n"
-        << "  static std::optional<Type> from(const ::mx::ir::Type &);\n"
-        << "};\n"
-        << "static_assert(sizeof(Type) == sizeof(::mx::ir::Type));\n\n";
-
-    cpp
-        << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-        << "//\n"
-        << "// This source code is licensed in accordance with the terms specified in\n"
-        << "// the LICENSE file found in the root directory of this source tree.\n\n"
-        << "// Auto-generated file; do not modify!\n\n"
-        << "#include <multiplier/IR/" << dialect.our_dir_name.generic_string()
-        << "/Type.h>\n\n"
-        << "#include <multiplier/IR/Attribute.h>\n\n";
-
-    std::set<std::string> seen;
-    for (Type *type : dialect.types) {
-      for (const auto &[id, path] : include_paths[IncludePathFor(type->cls)]) {
-        if (seen.emplace(path).second) {
-          cpp << "#include <" << path << ">\n";
-        }
-      }
-    }
-
-    cpp
-        << '\n'
-        << "namespace mx::ir::" << dialect.our_ns_name << " {\n"
-        << "std::optional<Type> Type::from(const ::mx::ir::Type &that) {\n"
-        << "  if (Is" << dialect.name << "TypeKind(that.kind())) {\n"
-        << "    return reinterpret_cast<const Type &>(that);\n"
-        << "  }\n"
-        << "  return std::nullopt;\n"
-        << "}\n\n";
-
-    for (Type *type : dialect.types) {
-      std::string type_name = TypeNameToClassCase(type->name);
-      std::string enum_name = TypeNameToEnumCase(dialect, type->name);
-
-      hpp
-          << "class MX_EXPORT " << type_name << " final : public Type {\n"
-          << " public:\n"
-          << "  inline static constexpr TypeKind static_kind(void) {\n"
-          << "    return TypeKind::" << enum_name
-          << ";\n"
-          << "  }\n\n"
-          << "  static std::optional<" << type_name << "> from(const ::mx::ir::Type &that);\n"
-          << "  ::" << dialect.ns_key
-          << "::" << type->name << " underlying_repr(void) const noexcept;\n\n"
-          << "  // Imported methods:\n";
-
-      cpp
-          << "std::optional<" << type_name << "> " << type_name
-          << "::from(const ::mx::ir::Type &that) {\n"
-          << "  if (that.kind() == TypeKind::" << enum_name << ") {\n"
-          << "    return reinterpret_cast<const " << type_name << " &>(that);\n"
-          << "  }\n"
-          << "  return std::nullopt;\n"
-          << "}\n\n"
-          << "::" << dialect.ns_key << "::" << type->name
-          << " " << type_name << "::underlying_repr(void) const noexcept {\n"
-          << "  return ::" << dialect.ns_key << "::" << type->name << "(this->::mx::ir::Type::type_);\n"
-          << "}\n\n";
-
-      std::set<std::string> seen_methods;
-      for (const pasta::CXXMethodDecl &meth : type->methods) {
-        DoMethod(meth, hpp, cpp, type, type_name, seen_methods);
-      }
-
-      hpp
-          << "};\n"
-          << "static_assert(sizeof(" << type_name << ") == sizeof(Type));\n\n";
-    }
-
-    hpp 
-        << "}  // namespace mx::ir::" << dialect.our_ns_name << "\n";
-
-    cpp 
-        << "}  // namespace mx::ir::" << dialect.our_ns_name << "\n";
-  }
-}
-
-static std::string AttrNameToSnakeCase(std::string_view type_name) {
-  if (type_name.ends_with("Attr")) {
-    type_name.remove_suffix(4);
-  }
-
-  return CapitalCaseToSnakeCase(type_name);
-}
-
-static std::string AttrNameToEnumCase(const Dialect &dialect,
-                                      std::string_view type_name) {
-  if (type_name.starts_with("Attr")) {
-    type_name.remove_prefix(4);
-  }
-  if (type_name.starts_with('_')) {
-    type_name.remove_prefix(1);
-  }
-  return OpNameToEnumCase(dialect.our_ns_name) + '_' +
-         OpNameToEnumCase(AttrNameToSnakeCase(type_name));
-}
-
-static std::string FinalizeAttrNameToClassCase(std::string ret) {
-  return ret + "Attr";
-}
-
-static std::string AttrNameToClassCase(std::string_view name) {
-  if (name.ends_with("Attr")) {
-    name.remove_suffix(4);
-  }
-
-  if (name.starts_with("llvm") || name.starts_with("LLVM")) {
-    name.remove_prefix(4);
-  }
-
-  if (name.starts_with('_')) {
-    name.remove_prefix(1);
-  }
-
-  if (std::isupper(name[0])) {
-    return FinalizeAttrNameToClassCase(std::string(name.begin(), name.end()));
-  }
-
-  return FinalizeAttrNameToClassCase(Capitalize(SnakeCaseToCamelCase(name)));
-}
-
-void CodeGenerator::RunOnAttrs(void) {
-  // "/Users/pag/Code/multiplier/bin/Bootstrap/VAST.cpp"
-  std::filesystem::path file = __FILE__;
-  std::filesystem::path mx_root = file.parent_path().parent_path().parent_path();
-  std::filesystem::path mx_inc = mx_root / "include" / "multiplier";
-  std::filesystem::path mx_lib = mx_root / "lib";
-
-  std::ofstream hpp(mx_inc / "IR" / "AttributeKind.h");
-  std::ofstream cpp(mx_lib / "IR" / "Attribute.h");  // In lib.
-
-  hpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n"
-      << "#pragma once\n\n"
-      << "#include \"../Compiler.h\"\n\n"
-      << "namespace mx {\n"
-      << "namespace ir {\n"
-      << "enum class AttributeKind : unsigned {\n"
-      << "  UNKNOWN,\n";
-
-  auto num_attrs = 0u;
-  for (Dialect &dialect : gDialects) {
-    for (Attr *attr : dialect.attrs) {
-      hpp << "  " << AttrNameToEnumCase(dialect, attr->name) << ",\n";
-      ++num_attrs;
-    }
-  }
-
-  hpp
-      << "};\n\n"
-      << "}  // namespace ir\n\n"
-      << "inline static const char *EnumerationName(ir::AttributeKind) {\n"
-      << "  return \"AttributeKind\";\n"
-      << "}\n\n"
-      << "inline static constexpr unsigned NumEnumerators(ir::AttributeKind) {\n"
-      << "  return " << num_attrs << ";\n"
-      << "}\n\n"
-      << "MX_EXPORT const char *EnumeratorName(ir::AttributeKind);\n\n";
-
-  for (Dialect &dialect : gDialects) {
-    hpp
-        << "MX_EXPORT bool Is" << dialect.name << "AttributeKind(ir::AttributeKind);\n\n";
-  }
-
-  hpp
-      << "}  // namespace mx\n";
-
-  cpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n"
-      << "#pragma once\n\n";
-
-  auto sep = "#define MX_IR_FOR_EACH_MLIR_ATTRIBUTE(";
-
-  for (Dialect &dialect : gDialects) {
-    cpp << sep << '_' << dialect.our_ns_name;
-    sep = ", ";
-  }
-
-  cpp << ")";
-
-  for (Dialect &dialect : gDialects) {
-    for (Attr *attr : dialect.attrs) {
-      cpp << " \\\n   _" << dialect.our_ns_name << "(" << attr->name << ", AttributeKind::"
-          << AttrNameToEnumCase(dialect, attr->name) << ", " << dialect.ns_key << "::"
-          << attr->name << ")";
-    }
-  }
-
-  cpp
-      << "\n\n"
-      << "#define MX_IR_NUM_MLIR_ATTRIBUTES " << num_attrs << "\n\n";
-
-  cpp.close();
-  cpp.open(mx_lib / "IR" / "AttributeKind.cpp");  // In lib.
-  cpp
-      << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-      << "//\n"
-      << "// This source code is licensed in accordance with the terms specified in\n"
-      << "// the LICENSE file found in the root directory of this source tree.\n\n"
-      << "// Auto-generated file; do not modify!\n\n"
-      << "#include <multiplier/IR/AttributeKind.h>\n\n"
-      << "namespace mx {\n\n"
-      << "const char *EnumeratorName(ir::AttributeKind kind) {\n"
-      << "  switch (kind) {\n"
-      << "    default: return \"UNKNOWN\";\n";
-
-  for (Dialect &dialect : gDialects) {
-    for (Attr *attr : dialect.attrs) {
-      std::string ec = AttrNameToEnumCase(dialect, attr->name);
-      cpp << "    case ir::AttributeKind::" << ec << ": return \"" << ec << "\";\n";
-    }
-  }
-
-  cpp << "  }\n"
-      << "}\n\n";
-
-  for (Dialect &dialect : gDialects) {
-    cpp
-        << "bool Is" << dialect.name << "AttributeKind(ir::AttributeKind kind) {\n"
-        << "  switch (kind) {\n"
-        << "    default:\n"
-        << "      return false;\n";
-
-    bool any = false;
-    for (Attr *attr : dialect.attrs) {
-      std::string enum_name = AttrNameToEnumCase(dialect, attr->name);
-      cpp << "    case mx::ir::AttributeKind::" << enum_name << ":\n";
-      any = true;
-    }
-
-    if (any) {
-      cpp
-          << "      return true;\n";
-    }
-    
-    cpp
-        << "  }\n"
-        << "}\n\n";
-  }
-
-  cpp
-      << "}  // namespace mx\n";
-
-  for (Dialect &dialect : gDialects) {
-    if (dialect.attrs.empty()) {
-      continue;
-    }
-
-    std::error_code ec;
-    (void) std::filesystem::create_directories(mx_inc / "IR" / dialect.our_dir_name, ec);
-    (void) std::filesystem::create_directories(mx_lib / "IR" / dialect.our_dir_name, ec);
-    
-    hpp.close();
-    hpp.open(mx_inc / "IR" / dialect.our_dir_name / "Attribute.h");
-
-    cpp.close();
-    cpp.open(mx_lib / "IR" / dialect.our_dir_name / "Attribute.cpp");
-
-    hpp
-        << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-        << "//\n"
-        << "// This source code is licensed in accordance with the terms specified in\n"
-        << "// the LICENSE file found in the root directory of this source tree.\n\n"
-        << "// Auto-generated file; do not modify!\n\n"
-        << "#pragma once\n\n"
-        << "#include \"../Attribute.h\"\n\n"
-        << "namespace " << dialect.ns_key << " {\n";
-
-    for (Attr *attr : dialect.attrs) {
-      hpp << "class " << attr->name << ";\n";
-    }
-
-    hpp
-        << "}  // namespace " << dialect.ns_key << "\n"
-        << "namespace mx::ir::" << dialect.our_ns_name << " {\n\n"
-        << "class MX_EXPORT Attribute : public ::mx::ir::Attribute {\n"
-        << " public:\n"
-        << "  static std::optional<Attribute> from(const ::mx::ir::Attribute &);\n"
-        << "};\n"
-        << "static_assert(sizeof(Attribute) == sizeof(::mx::ir::Attribute));\n\n";
-
-    cpp
-        << "// Copyright (c) 2023-present, Trail of Bits, Inc.\n"
-        << "//\n"
-        << "// This source code is licensed in accordance with the terms specified in\n"
-        << "// the LICENSE file found in the root directory of this source tree.\n\n"
-        << "// Auto-generated file; do not modify!\n\n"
-        << "#include <multiplier/IR/" << dialect.our_dir_name.generic_string()
-        << "/Attribute.h>\n\n"
-        << "#include <multiplier/IR/Type.h>\n\n";
-
-    std::set<std::string> seen;
-    for (Attr *attr : dialect.attrs) {
-      for (const auto &[id, path] : include_paths[IncludePathFor(attr->cls)]) {
-        if (seen.emplace(path).second) {
-          cpp << "#include <" << path << ">\n";
-        }
-      }
-    }
-
-    cpp
-        << '\n'
-        << "namespace mx::ir::" << dialect.our_ns_name << " {\n"
-        << "std::optional<Attribute> Attribute::from(const ::mx::ir::Attribute &that) {\n"
-        << "  if (Is" << dialect.name << "AttributeKind(that.kind())) {\n"
-        << "    return reinterpret_cast<const Attribute &>(that);\n"
-        << "  }\n"
-        << "  return std::nullopt;\n"
-        << "}\n\n";
-
-    for (Attr *attr : dialect.attrs) {
-      std::string attr_name = AttrNameToClassCase(attr->name);
-      std::string snake_name = AttrNameToSnakeCase(attr->name);
-      std::string enum_name = AttrNameToEnumCase(dialect, attr->name);
-
-      hpp
-          << "class MX_EXPORT " << attr_name << " final : public Attribute {\n"
-          << " public:\n"
-          << "  inline static constexpr AttributeKind static_kind(void) {\n"
-          << "    return AttributeKind::" << enum_name
-          << ";\n"
-          << "  }\n\n"
-          << "  static std::optional<" << attr_name << "> from(const ::mx::ir::Attribute &that);\n\n"
-          << "  ::" << dialect.ns_key
-          << "::" << attr->name << " underlying_repr(void) const noexcept;\n\n"
-          << "  // Imported methods:\n";
-
-      cpp
-          << "std::optional<" << attr_name << "> " << attr_name
-          << "::from(const ::mx::ir::Attribute &that) {\n"
-          << "  if (that.kind() == AttributeKind::" << enum_name << ") {\n"
-          << "    return reinterpret_cast<const " << attr_name << " &>(that);\n"
-          << "  }\n"
-          << "  return std::nullopt;\n"
-          << "}\n\n"
-          << "::" << dialect.ns_key << "::" << attr->name
-          << " " << attr_name << "::underlying_repr(void) const noexcept {\n"
-          << "  return ::" << dialect.ns_key << "::" << attr->name
-          << "(this->::mx::ir::Attribute::attr_);\n"
-          << "}\n\n";
-
-      std::set<std::string> seen_methods;
-      for (const pasta::CXXMethodDecl &meth : attr->methods) {
-        DoMethod(meth, hpp, cpp, attr, attr_name, seen_methods);
-      }
-
-      hpp
-          << "};\n"
-          << "static_assert(sizeof(" << attr_name << ") == sizeof(Attribute));\n\n";
-    }
-
-    hpp
-        << "}  // namespace mx::ir::" << dialect.our_ns_name << "\n";
-
-    cpp
-        << "}  // namespace mx::ir::" << dialect.our_ns_name << "\n";
-  }
-}
-
-void CodeGenerator::RunOnOpClass(const std::string &root_ns, const std::string &ns,
-                                 const pasta::CXXRecordDecl &cls,
-                                 std::vector<pasta::CXXMethodDecl> methods,
-                                 std::vector<std::string_view> attributes,
-                                 std::string_view op_name) {
-  Op &op = ops.emplace_back(cls);
-  op.root_ns = root_ns;
-  op.ns = ns;
-  op.name = cls.Name();
-  op.op_name = op_name;
-  op.methods = std::move(methods);
-  op.attributes = std::move(attributes);
-
-//  std::cerr << "OP: " << root_ns << "::" << ns << "::" << cls.Name() << " = "
-//            << op_name << '\n';
-//  for (const pasta::CXXMethodDecl &meth : methods) {
-//    std::string meth_name = meth.Name();
-//    std::string api_name = MethodName(meth_name);
-//    std::cerr << "\t" << meth_name << " -> " << api_name << '\n';
-//  }
-}
-
-void CodeGenerator::RunOnTypeClass(
-    const std::string &root_ns, const std::string &ns,
-    const pasta::CXXRecordDecl &cls, std::vector<pasta::CXXMethodDecl> methods,
-    std::vector<pasta::CXXMethodDecl> dl_methods, std::string_view op_name) {
-
-  Type &op = types.emplace_back(cls);
-  op.root_ns = root_ns;
-  op.ns = ns;
-  op.name = cls.Name();
-  op.mnemonic = op_name;
-  op.methods = std::move(methods);
-  op.datalayout_methods = std::move(dl_methods);
-
-//  std::string name = cls.Name();
-//  std::cerr << "TYPE: " << root_ns << "::" << ns << "::" << name << " = "
-//            << op_name << '\n';
-//
-//  for (const pasta::CXXMethodDecl &meth : dl_methods) {
-//    std::string meth_name = meth.Name();
-//    std::string api_name = MethodName(meth_name);
-//    std::cerr << "\t" << meth_name << " -> " << api_name << '\n';
-//  }
-//
-//  for (const pasta::CXXMethodDecl &meth : methods) {
-//    std::string meth_name = meth.Name();
-//    std::string api_name = MethodName(meth_name);
-//    std::cerr << "\t" << meth_name << " -> " << api_name << '\n';
-//  }
-}
-
-void CodeGenerator::RunOnAttrClass(
-    const std::string &root_ns, const std::string &ns,
-    const pasta::CXXRecordDecl &cls, std::vector<pasta::CXXMethodDecl> methods,
-    std::string_view op_name) {
-
-  Attr &op = attrs.emplace_back(cls);
-  op.root_ns = root_ns;
-  op.ns = ns;
-  op.name = cls.Name();
-  op.mnemonic = op_name;
-  op.methods = std::move(methods);
-
-//  std::string name = cls.Name();
-//  std::cerr << "ATTR: " << root_ns << "::" << ns << "::" << name << " = "
-//            << op_name << '\n';
-//  for (const pasta::CXXMethodDecl &meth : methods) {
-//    std::string meth_name = meth.Name();
-//    std::string api_name = MethodName(meth_name);
-//    std::cerr << "\t" << meth_name << " -> " << api_name << '\n';
-//  }
-}
-
-static std::unordered_map<std::string, std::string_view> kOpName{
-  {"LLVMVoidType", "llvm.void"},
-  {"LLVMX86MMXType", "llvm.x86_mmx"},
-  {"LLVMPPCFP128Type", "llvm.ppc_fp128"},
-  {"LLVMTokenType", "llvm.token"},
-  {"LLVMMetadataType", "llvm.metadata"},
-  {"LLVMLabelType", "llvm.label"},
-  {"LLVMStructType", "llvm.struct"},
-};
-
-void CodeGenerator::RunOnClasses(const std::string &root_ns, const std::string &ns,
-                                 std::vector<pasta::CXXRecordDecl> classes) {
-  for (const pasta::CXXRecordDecl &cls : classes) {
-    if (!seen_decls.emplace(cls.RawDecl()).second) {
-      continue;
-    }
-
-    if (!seen_decls.emplace(cls.CanonicalDeclaration().RawDecl()).second) {
-      continue;
-    }
-
-    std::string name = cls.Name();
-
-    if (name.ends_with("Adaptor") || name.ends_with("Builder") ||
-        name.ends_with("Interface") || name.ends_with("Parser") ||
-        name.ends_with("Pattern") || name.ends_with("Benefit") ||
-        name.ends_with("Handler") || name.ends_with("Engine") ||
-        name.ends_with("Result") || name.ends_with("Rewriter")) {
-      continue;
-    }
-
-    // Not a type, an op interface.
-    if (name == "GetResultPtrElementType") {
-      continue;
-    }
-
-    std::optional<std::vector<pasta::CXXMethodDecl>> methods = cls.Methods();
-    std::vector<pasta::CXXMethodDecl> methods_to_wrap;
-    std::vector<pasta::CXXMethodDecl> datalayout_methods;
-    std::vector<std::string_view> attributes;
-
-    std::string_view op_name = kOpName[name];
-
-    for (pasta::CXXMethodDecl &meth : methods.value()) {
-
-      switch (meth.Kind()) {
-        case pasta::DeclKind::kCXXConstructor:
-        case pasta::DeclKind::kCXXConversion:
-        case pasta::DeclKind::kCXXDeductionGuide:
-        case pasta::DeclKind::kCXXDestructor:
-          continue;
-        default:
-          break;
-      }
-
-      std::string meth_name = meth.Name();
-      if (meth_name.starts_with("getODS") || meth_name.starts_with("verify") ||
-          meth_name.starts_with("set") || meth_name == "build" ||
-          meth_name == "print" || meth_name == "parse" ||
-          meth_name.ends_with("Mutable") || meth_name.starts_with("remove") ||
-          (meth_name.starts_with("get") && meth_name.ends_with("AttrName"))) {
-        continue;
-      }
-
-      if (meth_name == "getOperationName") {
-        op_name = FindName(meth);
-        continue;
-      } else if (meth_name == "getMnemonic") {
-        op_name = FindName(meth);
-        continue;
-
-      } else if (meth_name == "getAttributeNames") {
-        attributes = FindNames(meth);
-        continue;
-      }
-
-      if (meth.NumParameters()) {
-        if (meth_name == "getTypeSizeInBits" ||
-            meth_name == "getABIAlignment" ||
-            meth_name == "getPreferredAlignment") {
-          datalayout_methods.emplace_back(std::move(meth));
-        }
-        continue;
-      }
-
-      // We often see things like `getNameAttr` followed by `getName`. Identify
-      // these and keep only the latter.
-      if (!methods_to_wrap.empty() &&
-          methods_to_wrap.back().Name() == (meth_name + "Attr")) {
-        methods_to_wrap.pop_back();
-      }
-
-      methods_to_wrap.emplace_back(std::move(meth));
-    }
-
-    if (name != "Attr" && name.ends_with("Attr")) {
-      RunOnAttrClass(root_ns, ns, cls, std::move(methods_to_wrap), op_name);
-
-    } else if (name != "Type" && name.ends_with("Type")) {
-      RunOnTypeClass(root_ns, ns, cls, std::move(methods_to_wrap),
-                     std::move(datalayout_methods), op_name);
-
-    // TODO(pag): Handle `Loc` classes.
-
-    } else if (!op_name.empty()) {
-      RunOnOpClass(root_ns, ns, cls, std::move(methods_to_wrap),
-                   std::move(attributes), op_name);
-
-    } else {
-      std::cerr << "SKIPPING CLASS: " << root_ns << "::" << ns << "::" << name << '\n';
-    }
-  }
-}
-
-void CodeGenerator::RunOnEnums(
-    const std::string &root_ns, const std::string &ns,
-    std::vector<pasta::EnumDecl> enums) {
-
-  for (const pasta::EnumDecl &e : enums) {
-    std::string name = e.Name();
-    std::cerr << "ENUM: " << root_ns << "::" << ns << "::" << name << '\n';
-  }
-}
-
-void CodeGenerator::RunOnNamespace(const pasta::NamespaceDecl &root_ns,
-                                   pasta::NamespaceDecl ns) {
-  std::string root_ns_name = root_ns.Name();
-  std::string ns_name = ns.Name();
-
-  if (root_ns_name == "vast") {
-    if (ns_name != "hl" && ns_name != "ll" && ns_name != "meta" &&
-        ns_name != "core" && ns_name != "unsup" && ns_name != "abi") {
-      return;
-    }
-  } else if (root_ns_name == "mlir") {
-    if (ns_name != "LLVM" && ns_name != "memref") {
-      return;
-    }
-
-  } else {
-    return;
-  }
-
-  std::vector<pasta::CXXRecordDecl> classes;
-  std::vector<pasta::EnumDecl> enums;
-
-  for (auto decl : pasta::DeclContext(ns).Declarations()) {
-    if (auto cls = pasta::CXXRecordDecl::From(decl);
-        cls && cls->IsThisDeclarationADefinition()) {
-      classes.emplace_back(std::move(cls.value()));
-    } else if (auto e = pasta::EnumDecl::From(decl);
-               e && e->IsThisDeclarationADefinition()) {
-      enums.emplace_back(std::move(e.value()));
-    }
-  }
-
-  RunOnEnums(root_ns_name, ns_name, std::move(enums));
-  RunOnClasses(root_ns_name, ns_name, std::move(classes));
-}
-
-std::string CodeGenerator::TopIncludePath(std::string path) {
-  for (auto end = included_by.end(); ;) {
-    auto it = included_by.find(path);
-    if (it == end) {
-      break;
-    } else {
-      path = it->second;
-    }
-  }
-  return path;
-}
-
-void CodeGenerator::FindIncludePaths(pasta::MacroRange macros,
-                                     pasta::File main_file) {
-  for (pasta::Macro m : macros) {
-    auto inc = pasta::IncludeMacroDirective::From(m);
-    if (!inc) {
-      continue;
-    }
-
-    auto dest_file = inc->IncludedFile();
-    if (!dest_file) {
-      continue;
-    }
-
-    auto bt = inc->BeginToken();
-    if (!bt) {
-      continue;
-    }
-
-    auto fbt = bt->FileLocation();
-    if (!fbt) {
-      continue;
-    }
-
-    auto src_file = pasta::File::Containing(fbt.value());
-    if (src_file == main_file) {
-      continue;
-    }
-
-    auto dest_path = RelativePath(dest_file->Path());
-    auto src_path = RelativePath(src_file.Path());
-    if (!dest_path.empty() && !src_path.empty()) {
-      included_by.emplace(dest_path, src_path);
-    }
-  }
-}
-
-void CodeGenerator::RunOnAST(pasta::AST ast) {
-  FindIncludePaths(ast.Macros(), ast.MainFile());
-  RunOnTranslationUnit(ast.TranslationUnit());
-}
-
-void CodeGenerator::RunOnTranslationUnit(pasta::TranslationUnitDecl tu) {
-
-  std::vector<pasta::CXXRecordDecl> classes;
-  std::vector<pasta::EnumDecl> enums;
-
-  // TODO(pag): Need to go deeper into vast::hl, ::ll
-
-  for (auto decl : pasta::DeclContext(tu).Declarations()) {
-    auto ns = pasta::NamespaceDecl::From(decl);
-    if (!ns) {
-      continue;
-    }
-
-    std::string ns_name = ns->Name();
-
-    for (pasta::Decl sub_decl : pasta::DeclContext(ns.value()).Declarations()) {
-      if (auto sub_ns = pasta::NamespaceDecl::From(sub_decl)) {
-        RunOnNamespace(ns.value(), std::move(sub_ns.value()));
-
-      } else if (ns_name == "mlir") {
-        if (auto cls = pasta::CXXRecordDecl::From(sub_decl);
-            cls && cls->IsThisDeclarationADefinition()) {
-          classes.emplace_back(std::move(cls.value()));
-
-        } else if (auto e = pasta::EnumDecl::From(sub_decl);
-                   e && e->IsThisDeclarationADefinition()) {
-          enums.emplace_back(std::move(e.value()));
-        }
-      }
-    }
-  }
-
-  if (!enums.empty()) {
-    RunOnEnums("", "mlir", std::move(enums));
-  }
-  if (!classes.empty()) {
-    RunOnClasses("", "mlir", std::move(classes));
-  }
-}
-
-CodeGenerator::CodeGenerator(char *[]) {}
-
-int main(int argc, char *argv[]) {
-//  if (12 != argc) {
-//    std::cerr
-//        << "Usage: " << argv[0]
-//        << " VAST_INCLUDE_PATH DEPENDENCIES_INC_PATH LLVM_INCLUDE_PATH "
-//        << std::endl;
-//    return EXIT_FAILURE;
-//  }
-
-  std::cerr  << "Bootstrap command:\n";
-  auto sep = "\t";
-  for (auto i = 0; i < argc; ++i) {
-    std::cerr << sep << argv[i];
-    sep = " ";
-  }
-  std::cerr << "\n\n";
-
-
-  pasta::InitPasta initializer;
-  pasta::FileManager fm(pasta::FileSystem::CreateNative());
-  auto maybe_compiler =
-      pasta::Compiler::CreateHostCompiler(fm, pasta::TargetLanguage::kCXX);
-  if (!maybe_compiler.Succeeded()) {
-    std::cerr << maybe_compiler.TakeError() << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  auto fs = pasta::FileSystem::From(maybe_compiler.Value());
-  auto maybe_cwd = fs->CurrentWorkingDirectory();
-  if (!maybe_cwd.Succeeded()) {
-    std::cerr << maybe_compiler.TakeError() << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  auto exe_path = maybe_compiler->ExecutablePath();
-  std::vector<const char *> cc_args{
-      exe_path.c_str(),
-      "-x", "c++",
-      "-std=c++23",
-      "-c", __FILE__,
-      "-o", "/dev/null",
-      "-isystem", argv[1],  // Install include dir.
-      "-isystem", argv[2],  // Dependencies include dir.
-      "-isystem", argv[3],  // LLVM include dir.
-      "-DMX_IN_BOOTSTRAP",
-      "-DGAP_ENABLE_COROUTINES"};
-
-  const pasta::ArgumentVector args(cc_args);
-  auto maybe_command = pasta::CompileCommand::CreateFromArguments(
-      args, maybe_cwd.TakeValue());
-  if (!maybe_command.Succeeded()) {
-    std::cerr << maybe_command.TakeError() << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  const pasta::CompileCommand command = maybe_command.TakeValue();
-
-  std::cerr
-      << "Self-parsing with:\n\t"
-      << command.Arguments().Join() << "\n\n";
-
-  auto maybe_jobs = maybe_compiler->CreateJobsForCommand(command);
-  if (!maybe_jobs.Succeeded()) {
-    std::cerr << maybe_jobs.TakeError() << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  CodeGenerator cg(argv);
-
-  for (const pasta::CompileJob &job : maybe_jobs.TakeValue()) {
-    auto maybe_ast = job.Run();
-    if (!maybe_ast.Succeeded()) {
-      std::cerr << maybe_ast.TakeError() << std::endl;
-      return EXIT_FAILURE;
-    } else {
-      cg.RunOnAST(maybe_ast.TakeValue());
-    }
-  }
-
-  cg.Summarize();
-  cg.RunOnOps();
-  cg.RunOnTypes();
-  cg.RunOnAttrs();
-
-  return EXIT_SUCCESS;
-}
-
-#endif  // !defined(MX_IN_BOOTSTRAP)
diff --git a/bin/Examples/CMakeLists.txt b/bin/Examples/CMakeLists.txt
index 30bb162f9..8cb67a2db 100644
--- a/bin/Examples/CMakeLists.txt
+++ b/bin/Examples/CMakeLists.txt
@@ -89,8 +89,5 @@ define_example("mx-taint-entity" "TaintEntity.cpp")
 define_example("mx-harness" "Harness.cpp")
 define_example("mx-print-type-token-graph" "PrintTypeTokenGraph.cpp")
 define_example("mx-find-linked-structures" "FindLinkedStructures.cpp")
-define_example("mx-count-sourceir" "CountSourceIR.cpp")
 define_example("mx-list-declarations-overlapping-macro-expansion"
   "ListDeclOverlappingMacroExpansions.cpp")
-
-# define_example("mx-print-sourceir" "PrintSourceIR.cpp")
diff --git a/bin/Examples/CountSourceIR.cpp b/bin/Examples/CountSourceIR.cpp
deleted file mode 100644
index 0bd02ec0d..000000000
--- a/bin/Examples/CountSourceIR.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright (c) 2022-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#include <cstdlib>
-#include <gflags/gflags.h>
-#include <glog/logging.h>
-#include <iostream>
-#include <sstream>
-
-#include <multiplier/Index.h>
-#include <multiplier/Frontend/Compilation.h>
-#include <multiplier/IR/Builtin/Operation.h>
-
-DECLARE_bool(help);
-DECLARE_string(db);
-
-int main(int argc, char *argv[]) {
-  std::stringstream ss;
-  ss
-    << "Usage: " << argv[0]
-    << " [--db DATABASE] --fragment_id ID\n";
-
-  google::SetUsageMessage(ss.str());
-  google::ParseCommandLineFlags(&argc, &argv, false);
-  google::InitGoogleLogging(argv[0]);
-
-  if (FLAGS_help) {
-    std::cerr << google::ProgramUsage() << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  mx::Index index(mx::Index::from_database(FLAGS_db));
-
-  uint64_t num_tus = 0u;
-  uint64_t num_mlir = 0u;
-  uint64_t num_files = 0u;
-  uint64_t num_frags = 0u;
-  uint64_t num_errors = 0u;
-  uint64_t num_macros = 0u;
-
-  for (mx::Compilation tu : index.compilations()) {
-    ++num_tus;
-    if (std::optional<mx::ir::builtin::ModuleOp> mlir = tu.ir()) {
-      ++num_mlir;
-    } else {
-      ++num_errors;
-    }
-  }
-
-  for (mx::File file: index.files()) {
-    ++num_files;
-
-    for (mx::Fragment frag : file.fragments()) {
-      ++num_frags;
-
-      auto has_tld = false;
-      for (auto tld : frag.top_level_declarations()) {
-        has_tld = true;
-        break;
-      }
-
-      if (!has_tld) {
-        ++num_macros;
-      }
-    }
-  }
-
-  std::cout
-      << "File count: " << num_files
-      << "\nCompilation unit count: " << num_tus
-      << "\nCompilation units with MLIR: " << num_mlir
-      << "\nCompilation units without MLIR: " << num_errors
-      << "\nFragment count: " << num_frags
-      << "\nMacro fragments: " << num_macros
-      << "\n";
-
-  return EXIT_SUCCESS;
-}
diff --git a/bin/Examples/PrintSourceIR.cpp b/bin/Examples/PrintSourceIR.cpp
deleted file mode 100644
index f1de931a0..000000000
--- a/bin/Examples/PrintSourceIR.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright (c) 2022-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#include <cstdlib>
-#include <gflags/gflags.h>
-#include <glog/logging.h>
-#include <iostream>
-#include <sstream>
-
-#include <multiplier/Index.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/MLIR/Builtin/ModuleOp.h>
-#include <multiplier/IR/Region.h>
-
-DECLARE_bool(help);
-DECLARE_string(db);
-DEFINE_uint64(fragment_id, 0, "ID of the fragment to print");
-
-static void DumpOperand(const mx::ir::Operand &op, std::ostream &os) {
-  mx::ir::Value val = op.value();
-  if (auto arg = mx::ir::Argument::from(val)) {
-    os << '%' << arg->index();
-
-  } else if (auto res = mx::ir::Result::from(val)) {
-
-  } else {
-    os << "??UNKNOWN_VALUE??";
-  }
-}
-
-static void DumpBlock(const mx::ir::Block &b,
-                       std::ostream &os, const std::string &indent) {
-
-}
-
-static void DumpRegion(const mx::ir::Region &r,
-                       std::ostream &os, const std::string &indent) {
-  for (mx::ir::Block block : r.blocks()) {
-    DumpBlock(block, os, indent);
-  }
-}
-
-static void DumpOperation(const mx::ir::Operation &op,
-                          std::ostream &os, const std::string &indent) {
-  os << indent;
-
-  switch (op.num_results()) {
-    case 0:
-      break;
-    case 1:
-      os << " = ";
-      break;
-    default:
-      os << "[";
-      os << "] = ";
-  }
-
-  if (op.num_results()) {
-    os << " = ";
-  }
-
-  os << op.kind_name();
-  auto sep = "(";
-  for (mx::ir::Operand operand : op.operands()) {
-    os << sep;
-    DumpOperand(operand, os);
-    sep = ", ";
-  }
-  if (sep[0] == ',') {
-    os << ")";
-  }
-
-  std::string next_indent = indent + "  ";
-
-  if (op.num_regions()) {
-    os << ":\n";
-    auto is_first = true;
-    for (mx::ir::Region reg : op.regions()) {
-      if (!is_first) {
-        os << next_indent << "--\n";
-      }
-      DumpRegion(reg, os, next_indent);
-      is_first = false;
-    }
-  }
-  os << "\n";
-}
-
-int main(int argc, char *argv[]) {
-  std::stringstream ss;
-  ss
-    << "Usage: " << argv[0]
-    << " [--db DATABASE] --fragment_id ID\n";
-
-  google::SetUsageMessage(ss.str());
-  google::ParseCommandLineFlags(&argc, &argv, false);
-  google::InitGoogleLogging(argv[0]);
-
-  if (FLAGS_help) {
-    std::cerr << google::ProgramUsage() << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  mx::Index index(mx::Index::from_database(FLAGS_db));
-  std::optional<mx::Fragment> fragment = index.fragment(FLAGS_fragment_id);
-  if (!fragment) {
-    std::cerr << "Invalid fragment id " << FLAGS_fragment_id << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  if (std::optional<mx::ir::builtin::ModuleOp> mlir = fragment->ir()) {
-    DumpOperation(mlir.value(), std::cout, "");
-    std::cout << mlir->kind_name();
-  }
-
-  return EXIT_SUCCESS;
-}
diff --git a/bin/Index/BuildPendingFragment.cpp b/bin/Index/BuildPendingFragment.cpp
index cea9dbe61..946382110 100644
--- a/bin/Index/BuildPendingFragment.cpp
+++ b/bin/Index/BuildPendingFragment.cpp
@@ -311,11 +311,7 @@ bool PendingFragment::TryAdd(const pasta::Decl &entity) {
 }
 
 bool PendingFragment::TryAdd(const pasta::Stmt &entity) {
-
-  // If we're generating MLIR, then we need the entity IDs of statements to
-  // stay around until code generation time, as we only generate MLIR after
-  // persisting all fragments.
-  auto &entity_ids = em.generate_source_ir ? em.entity_ids : em.token_tree_ids;
+  auto &entity_ids = em.token_tree_ids;
 
   return DoTryAdd(
       entity,
@@ -401,8 +397,7 @@ bool PendingFragment::TryAdd(const pasta::Attr &entity) {
   // NOTE(pag): We can't rely on `attr.IsInherited()`, as Clang doesn't
   //            properly set this attribute for attributes inherited from
   //            pragmas.
-  EntityIdMap &entity_ids =
-      em.generate_source_ir ? em.entity_ids : em.token_tree_ids;
+  EntityIdMap &entity_ids = em.token_tree_ids;
 
   auto locator = RawEntity(entity);
   if (entity_ids.contains(locator)) {
diff --git a/bin/Index/CMakeLists.txt b/bin/Index/CMakeLists.txt
index f266d1a8a..65255b867 100644
--- a/bin/Index/CMakeLists.txt
+++ b/bin/Index/CMakeLists.txt
@@ -11,8 +11,6 @@ add_executable("${exe_name}"
   "Action.cpp"
   "Action.h"
   "BuildPendingFragment.cpp"
-  "Codegen.cpp"
-  "Codegen.h"
   "Context.cpp"
   "Context.h"
   "Endian.h"
diff --git a/bin/Index/Codegen.cpp b/bin/Index/Codegen.cpp
deleted file mode 100644
index 023ca00e8..000000000
--- a/bin/Index/Codegen.cpp
+++ /dev/null
@@ -1,580 +0,0 @@
-// Copyright (c) 2022-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#include "Codegen.h"
-
-#define VAST_ENABLE_EXCEPTIONS
-#include <vast/Util/Warnings.hpp>
-
-// Hack to get around `std::unique_ptr` issue with a `struct DelimitedScope`.
-#define LLVM_SUPPORT_SCOPEDPRINTER_H
-
-#include "ScopedPrinter.h"
-
-VAST_RELAX_WARNINGS
-#include <clang/AST/ASTContext.h>
-#include <clang/Tooling/Tooling.h>
-#include <llvm/Support/raw_ostream.h>
-#include <mlir/Bytecode/BytecodeWriter.h>
-#include <mlir/IR/Builders.h>
-#include <mlir/IR/Dialect.h>
-#include <mlir/IR/MLIRContext.h>
-#include <mlir/IR/OperationSupport.h>
-#include <mlir/IR/Verifier.h>
-#include <mlir/InitAllDialects.h>
-VAST_UNRELAX_WARNINGS
-
-#include <algorithm>
-#include <exception>
-#include <glog/logging.h>
-
-#include <pasta/AST/AST.h>
-#include <pasta/AST/Decl.h>
-
-#include <vast/CodeGen/AttrVisitorProxy.hpp>
-#include <vast/CodeGen/CodeGenBuilder.hpp>
-#include <vast/CodeGen/CodeGenDriver.hpp>
-#include <vast/CodeGen/CodeGenMetaGenerator.hpp>
-#include <vast/CodeGen/CodeGenPolicy.hpp>
-#include <vast/CodeGen/CodeGenVisitorList.hpp>
-#include <vast/CodeGen/DefaultVisitor.hpp>
-#include <vast/CodeGen/UnsupportedVisitor.hpp>
-#include <vast/CodeGen/DataLayout.hpp>
-#include <vast/CodeGen/DefaultCodeGenPolicy.hpp>
-#include <vast/CodeGen/DefaultVisitor.hpp>
-#include <vast/CodeGen/FallthroughVisitor.hpp>
-#include <vast/CodeGen/ScopeContext.hpp>
-#include <vast/CodeGen/SymbolGenerator.hpp>
-#include <vast/CodeGen/TypeCachingProxy.hpp>
-#include <vast/CodeGen/UnsupportedVisitor.hpp>
-
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/Meta/MetaAttributes.hpp>
-
-#include <vast/Frontend/Options.hpp>
-
-#include <vast/Util/Common.hpp>
-#include <vast/Util/DataLayout.hpp>
-
-#include "EntityMapper.h"
-#include "NameMangler.h"
-#include "TypeMapper.h"
-#include "Util.h"
-
-#include "../../lib/IR/SourceIR.h"
-
-namespace indexer {
-namespace {
-
-class CodeGeneratorError final : public std::runtime_error {
-public:
-  explicit CodeGeneratorError(const std::string &message)
-      : std::runtime_error(message) {}
-
-  CodeGeneratorError(void)
-      : std::runtime_error("Code generation error occurred") {}
-};
-
-// Generate `mlir::Location`s for Clang decls/stmts/etc. The location isn't
-// the typical `file:line:col`, but instead embeds the entity ID for the Clang
-// object, so that we can then correlate VAST-produced MLIR entities saved
-// by Multiplier to its database.
-class MetaGenerator final : public vast::cg::meta_generator {
-  // Entity mapper; The entity id gets embedded as metadata
-  const EntityMapper &em;
-
-  // MLIR context for generating the MLIR location from source location
-  mlir::MLIRContext * const mctx;
-
-  mlir::Location unknown_location;
-
-public:
-
-  MetaGenerator(mlir::MLIRContext &mctx_, const EntityMapper &em_)
-      : em(em_),
-        mctx(&mctx_),
-        unknown_location(mlir::UnknownLoc::get(mctx)) {}
-
-  mlir::Location location(const clang::Decl *data) const {
-    return location_impl(data);
-  }
-
-  mlir::Location location(const clang::Expr *data) const {
-    return location_impl(data);
-  }
-
-  mlir::Location location(const clang::Stmt *data) const {
-    return location_impl(data);
-  }
-
-private:
-  template <typename T> mlir::Location location_impl(const T *data) const {
-    auto raw_entity_id = em.EntityId(data);
-    if (raw_entity_id == mx::kInvalidEntityId) {
-      if constexpr (std::is_same_v<T, clang::Stmt> ||
-                    std::is_same_v<T, clang::Expr>) {
-        if (auto dre = clang::dyn_cast<clang::DeclRefExpr>(data)) {
-          dre->dumpColor();
-          assert(false);
-        }
-      }
-      return unknown_location;
-    }
-
-    auto attr = vast::meta::IdentifierAttr::get(mctx, raw_entity_id);
-    return mlir::FusedLoc::get({}, attr, mctx);
-  }
-};
-
-// Produce symbol names based on entity IDs, as Multiplier's name mangler won't
-// produce named for all the same thing;s that VAST's default symbol name
-// generator will.
-class SymbolGenerator final : public vast::cg::symbol_generator {
- private:
-  const EntityMapper &em;
-
-  std::unordered_map<const vast::cg::clang_decl *, std::string> names;
-  std::string id_name;
-  llvm::raw_string_ostream os;
-
-  std::optional<vast::cg::symbol_name> mangle(
-      const vast::cg::clang_decl *decl_) {
-
-    auto decl = decl_->getCanonicalDecl();
-    auto it = names.find(decl);
-    if (it != names.end()) {
-      return it->second;
-    }
-
-    // TODO(pag): This won't be good enough for namespaces, as they are
-    //            internalized into fragments.
-    auto id = em.EntityId(decl);
-    if (id == mx::kInvalidEntityId) {
-      return std::nullopt;
-    }
-
-    id_name.clear();
-    os << id;
-    it = names.emplace(decl, std::move(id_name)).first;
-    return it->second;
-  }
-
- public:
-  virtual ~SymbolGenerator(void) = default;
-
-  inline SymbolGenerator(const EntityMapper &em_)
-      : em(em_),
-        os(id_name) {}
-
-  std::optional<vast::cg::symbol_name> symbol(
-      vast::cg::clang_global global) final {
-    return mangle(global.getCanonicalDecl().getDecl());
-  }
-
-  std::optional<vast::cg::symbol_name> symbol(
-      const vast::cg::clang_decl_ref_expr *ref) {
-    return mangle(ref->getDecl());
-  }
-};
-
-
-class ErrorReportVisitorProxy
-    : public vast::cg::fallthrough_list_node {
-  using base = vast::cg::fallthrough_visitor;
-
-  template <typename EntityType, typename NameFunc>
-  auto visit_impl(EntityType entity, vast::cg::scope_context &scope,
-                  const std::string &type, NameFunc name) {
-    auto unsup = next->visit(entity, scope);
-
-    if constexpr (std::is_same_v<EntityType, const vast::cg::clang_type *>
-              ||  std::is_same_v<EntityType, vast::cg::clang_qual_type>
-    ) {
-      log_type(type, name(ast, entity));
-    } else {
-      log(type, name(ast, entity), entity);
-    }
-
-    if (!unsup) {
-      throw CodeGeneratorError();
-    }
-
-    return unsup;
-  }
-
-  void log(std::string_view type, std::string_view name,
-           const auto *entity) const {
-    LOG(WARNING)
-        << "Cannot codegen unsupported " << type << " " << name
-        << PrefixedLocation(ast.Adopt(entity), " at or near ")
-        << " on main job file "
-        << ast.MainFile().Path().generic_string();
-  }
-
-  void log_type(std::string_view type, std::string_view name) const {
-    LOG(WARNING)
-        << "Cannot codegen unsupported " << type << " " << name
-        << " on main job file "
-        << ast.MainFile().Path().generic_string();
-  }
-
-public:
-  ErrorReportVisitorProxy(const pasta::AST &ast_)
-      : ast(ast_) {}
-
-  vast::operation visit(const vast::cg::clang_decl *raw_decl,
-                        vast::cg::scope_context &scope) override {
-    return visit_impl(raw_decl, scope, "declaration",
-                      [] (auto &ast, auto *raw) {
-                        return ast.Adopt(raw).KindName();
-                      });
-  }
-
-  vast::operation visit(const vast::cg::clang_stmt *raw_stmt,
-                        vast::cg::scope_context &scope) override {
-    return visit_impl(raw_stmt, scope, "statement",
-                      [] (auto &ast, auto *raw) {
-                        return ast.Adopt(raw).KindName();
-                      });
-  }
-
-  vast::mlir_type visit(const vast::cg::clang_type *type,
-                        vast::cg::scope_context &scope) override {
-    return visit_impl(type, scope, "type",
-                      [] (auto &, auto *t) {
-                        return vast::cg::clang_qual_type(t, 0).getAsString();
-                      });
-  }
-
-  vast::mlir_type visit(vast::cg::clang_qual_type type,
-                        vast::cg::scope_context &scope) override {
-    return visit_impl(type, scope, "type",
-                      [] (auto &, auto t) {
-                        return t.getAsString();
-                      });
-  }
-
-  std::optional<vast::named_attr> visit(
-      const vast::cg::clang_attr *raw_attr,
-      vast::cg::scope_context &scope) override {
-    return visit_impl(raw_attr, scope, "attribute", [](auto &ast, auto *raw) {
-      return ast.Adopt(raw).KindName();
-    });
-  }
-
-  vast::operation visit_prototype(const vast::cg::clang_function *raw_decl,
-                                  vast::cg::scope_context &scope) override {
-    return visit_impl(raw_decl, scope, "function prototype",
-                      [] (auto &, auto *raw) {
-                        return raw->getNameAsString();
-                      });
-  }
-
-private:
-  const pasta::AST &ast;
-};
-
-class PreprocessingVisitorProxy : public vast::cg::fallthrough_list_node {
- private:
-  clang::ASTContext &ast_context;
-  const EntityMapper &em;
-
-  int in_ce{0};
-  const vast::cg::clang_stmt *expected_ce{nullptr};
-
- public:
-  PreprocessingVisitorProxy(clang::ASTContext &ast_context_,
-                            const EntityMapper &em_)
-      : ast_context(ast_context_),
-        em(em_) {}
-
-  // Apply the `TypeMapper`s type compression, which eagerly desugars things
-  // like `AutoType`, `ElaboratedType`, etc. (but isn't as aggressive when
-  // the types are incomplete / dependent on template parameters), then ask
-  // VAST's default type code generator to handle things.
-  //
-  // E.g. if there was an `AutoType` that wrapped a `PointerType`, then here
-  // we'd forward the pointer type to `base`, then when `base` gets around to
-  // lifting the pointer element type into an MLIR type, it will call
-  // `Derived::visit`, the most derived type, and represents the "top" code
-  // generator visitor, which will lead us back into here to apply compression
-  // on the pointer element type.
-  vast::mlir_type visit(const vast::cg::clang_type *type,
-                        vast::cg::scope_context &scope) override {
-    auto compressed = compress(type);
-    auto new_type = compressed.getTypePtrOrNull();
-    if (new_type != type) {
-      if (compressed.hasQualifiers()) {
-        return visit(compressed, scope);
-      }
-    } else {
-      assert(!compressed.hasQualifiers());
-    }
-    return next->visit(new_type, scope);
-  }
-
-  vast::mlir_type visit(vast::cg::clang_qual_type type,
-                        vast::cg::scope_context &scope) override {
-    return next->visit(compress(type), scope);
-  }
-
-  // Don't codegen statements for fragments that aren't indexed as part of this
-  // translation unit.
-  vast::operation visit(const vast::cg::clang_stmt *raw_stmt,
-                        vast::cg::scope_context &scope) override {
-    auto eid = em.EntityId(raw_stmt);
-    if (eid != mx::kInvalidEntityId) {
-      return next->visit(raw_stmt, scope);
-    }
-
-    if (clang::isa<clang::ConstantExpr>(raw_stmt) ||
-        expected_ce == raw_stmt) {
-      ++in_ce;
-      auto ret = next->visit(raw_stmt, scope);
-      --in_ce;
-      return ret;
-    }
-
-    if (in_ce ||
-        clang::isa<clang::IntegerLiteral>(raw_stmt) ||
-        clang::isa<clang::ImaginaryLiteral>(raw_stmt) ||
-        clang::isa<clang::FloatingLiteral>(raw_stmt) ||
-        clang::isa<clang::FixedPointLiteral>(raw_stmt) ||
-        clang::isa<clang::CharacterLiteral>(raw_stmt) ||
-        clang::isa<clang::StringLiteral>(raw_stmt) ||
-        clang::isa<clang::ObjCStringLiteral>(raw_stmt) ||
-        clang::isa<clang::ObjCDictionaryLiteral>(raw_stmt) ||
-        clang::isa<clang::ObjCArrayLiteral>(raw_stmt)) {
-      return next->visit(raw_stmt, scope);
-    }
-
-    raw_stmt->dumpColor();
-    return {};
-  }
-
-  vast::operation visit(const vast::cg::clang_decl *raw_decl,
-                        vast::cg::scope_context &scope) override {
-
-    // Avoid having to lift constant expressions in enumerators. These will
-    // often be in different fragments.
-    if (auto enumerator = clang::dyn_cast<clang::EnumConstantDecl>(
-            const_cast<vast::cg::clang_decl *>(raw_decl))) {
-      auto old_init = enumerator->getInitExpr();
-      enumerator->setInitExpr(nullptr);
-      auto ret = next->visit(raw_decl, scope);
-      enumerator->setInitExpr(old_init);
-      return ret;
-    }
-
-    const auto old_expected_ce = expected_ce;
-
-    // VAST doesn't (yet) lift the field bitfield expressions, but if it
-    // eventually does, then mark them as expected constant expressions. They
-    // might be in different fragments. The expressions do, however, need to be
-    // present for the calculation of the bitfield with.
-    if (auto field = clang::dyn_cast<clang::FieldDecl>(raw_decl)) {
-      expected_ce = field->getBitWidth();
-    }
-
-    auto ret = next->visit(raw_decl, scope);
-    expected_ce = old_expected_ce;
-
-    // VAST will sometimes set the wrong visibility. We don't really care about
-    // the visibility.
-    if (clang::isa<clang::FunctionDecl>(raw_decl)) {
-      if (auto fn = mlir::dyn_cast<vast::hl::FuncOp>(ret)) {
-        mlir::SymbolTable::setSymbolVisibility(
-            fn, vast::cg::mlir_visibility::Public);
-      }
-    }
-
-    return ret;
-  }
-
- private:
-
-  vast::cg::clang_qual_type compress(const vast::cg::clang_type *type) {
-    return TypeMapper::Compress(ast_context, type);
-  }
-
-  vast::cg::clang_qual_type compress(vast::cg::clang_qual_type type) {
-    return TypeMapper::Compress(ast_context, type);
-  }
-};
-
-class CodeGenPolicy final : public vast::cg::codegen_policy {
- private:
-  const EntityMapper &em;
-  std::unordered_set<mx::RawEntityId> fragment_indexes;
-
- public:
-  CodeGenPolicy(const EntityMapper &em_,
-                std::vector<mx::PackedFragmentId> fragment_ids)
-      : em(em_) {
-
-    for (auto fid : fragment_ids) {
-      fragment_indexes.insert(fid.Unpack().fragment_id);
-    }
-  }
-
-  virtual ~CodeGenPolicy(void) = default;
-
-  bool emit_strict_function_return(
-      const vast::cg::clang_function *) const final {
-    return false;
-  };
-
-  enum vast::cg::missing_return_policy get_missing_return_policy(
-      const vast::cg::clang_function *) const final {
-    return vast::cg::missing_return_policy::emit_trap;
-  }
-
-  bool SkipDeclBody(const void *decl) const {
-    auto eid = em.EntityId(decl);
-    if (eid == mx::kInvalidEntityId) {
-      assert(false);
-      return true;
-    }
-
-    auto decl_id = mx::EntityId(eid).Extract<mx::DeclId>();
-    if (!decl_id) {
-      assert(false);
-      return false;
-    }
-
-    return !fragment_indexes.contains(decl_id->fragment_id);
-  }
-
-  bool skip_function_body(const vast::cg::clang_function *decl) const final {
-    return SkipDeclBody(decl);
-  }
-
-  bool skip_global_initializer(
-      const vast::cg::clang_var_decl *decl) const final {
-    return SkipDeclBody(decl);
-  }
-};
-
-static std::optional<vast::owning_mlir_module_ref> CreateModule(
-    const pasta::AST &ast, const EntityMapper &em,
-    std::vector<mx::PackedFragmentId> fragment_ids) try {
-
-  auto &actx = ast.UnderlyingAST();
-  auto &mctx = mx::ir::GlobalMLIRContext();
-  auto bld = vast::cg::mk_codegen_builder(mctx);
-  auto mg = std::make_shared<MetaGenerator>(mctx, em);
-  auto sg = std::make_shared<SymbolGenerator>(em);
-  auto cp = std::make_shared<CodeGenPolicy>(em, std::move(fragment_ids));
-  using vast::cg::as_node;
-  using vast::cg::as_node_with_list_ref;
-
-  auto visitors =
-      std::make_shared<vast::cg::visitor_list>() |
-      as_node<PreprocessingVisitorProxy>(ast.UnderlyingAST(), em) |
-      as_node_with_list_ref<vast::cg::attr_visitor_proxy>() |
-      as_node<vast::cg::type_caching_proxy>() |
-      as_node_with_list_ref<vast::cg::default_visitor>(
-          mctx, actx, *bld, mg, sg, cp) |
-      as_node<ErrorReportVisitorProxy>(ast) |
-      as_node_with_list_ref<vast::cg::unsup_visitor>(mctx, *bld, mg) |
-      as_node<vast::cg::fallthrough_visitor>();
-
-  vast::cg::driver driver(actx, mctx, std::move(bld), visitors);
-  driver.enable_verifier(true);
-
-  auto decls = GenerateDeclarationsInDeclContext(ast.TranslationUnit());
-  for (const auto &decl : decls) {
-    driver.emit(const_cast<clang::Decl *>(decl.RawDecl()));
-  }
-
-  driver.finalize();
-  return std::make_optional(driver.freeze());
-
-} catch (const CodeGeneratorError &e) {
-  LOG(ERROR) << "Error generating Source IR: " << e.what();
-  return std::nullopt;
-} catch (const std::exception &e) {
-  LOG(ERROR) << "Error verifying Source IR: " << e.what();
-  return std::nullopt;
-}
-
-static std::optional<std::string> DumpToString(
-    vast::owning_mlir_module_ref &mlir_module) {
-  std::string result;
-  llvm::raw_string_ostream os(result);
-  mlir::BytecodeWriterConfig config("MX");
-
-  if (mlir::failed(mlir::writeBytecodeToFile(mlir_module.get(), os, config))) {
-    return std::nullopt;
-  }
-
-  return std::make_optional(std::move(result));
-}
-
-} // namespace
-
-class CodeGeneratorImpl {
- public:
-  bool enabled = true;
-};
-
-CodeGenerator::CodeGenerator(void)
-    : impl(std::make_unique<CodeGeneratorImpl>()) {}
-
-void CodeGenerator::Disable(void) { impl->enabled = false; }
-
-bool CodeGenerator::IsEnabled(void) const { return impl->enabled; }
-
-CodeGenerator::~CodeGenerator(void) {
-  if (impl) {
-    impl.reset();
-  }
-}
-
-std::string CodeGenerator::GenerateSourceIR(
-    const pasta::AST &ast, const EntityMapper &em, const NameMangler &,
-    std::vector<mx::PackedFragmentId> fragment_ids) {
-
-  if (!IsEnabled()) {
-    return "";
-  }
-
-  auto mod = CreateModule(ast, em, std::move(fragment_ids));
-  if (!mod) {
-    return "";
-  }
-
-  // Set the flag to enable printing of debug information. The prettyForm
-  // flag passed to the function is set to false to avoid printing them in
-  // `pretty` form. This is because the IR generated in pretty form is not
-  // parsable.
-  auto flags = mlir::OpPrintingFlags();
-  flags.enableDebugInfo(true, false);
-
-  // Nifty for debugging, to see what the MLIR looked like.
-  if (false) {
-    std::error_code ec;
-    std::string out_file =
-        (std::filesystem::path("/tmp/src/") / ast.MainFile().Path().filename()).generic_string();
-    llvm::raw_fd_ostream os(out_file, ec);
-    if (!ec) {
-      (*mod)->print(os, flags);
-    } else {
-      LOG(ERROR) << ec.message();
-    }
-  }
-
-  if (auto result = DumpToString(mod.value())) {
-    return result.value();
-  }
-
-  LOG(ERROR)
-      << "Could not serialize module to bytecode on main job file "
-      << ast.MainFile().Path().generic_string();
-
-  return "";
-}
-
-} // namespace indexer
diff --git a/bin/Index/Codegen.h b/bin/Index/Codegen.h
deleted file mode 100644
index f8dd29ed3..000000000
--- a/bin/Index/Codegen.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (c) 2022-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#pragma once
-
-#include <memory>
-#include <multiplier/Types.h>
-#include <string>
-#include <vector>
-
-namespace pasta {
-class AST;
-class Decl;
-}  // namespace pasta
-namespace indexer {
-
-class EntityMapper;
-class NameMangler;
-class PendingFragment;
-
-class CodeGeneratorImpl;
-class CodeGenerator {
- private:
-  std::unique_ptr<CodeGeneratorImpl> impl;
-
- public:
-  CodeGenerator();
-
-  ~CodeGenerator();
-
-  void Disable();
-
-  bool IsEnabled() const;
-
-  // Generate Source IR from the top-level declarations. It uses vast
-  // emit_module API to lower the top-level declarations and save them
-  // to the persistent map with code ids.
-
-  // If there are more than one `FunctionDecl` in the list, the Source
-  // IR gets emitted to same module and saved with the same code ids. If
-  // the top-level declaration is not `FunctionDecl`, it will visit
-  // AST node and generate source ir for function decl found.
-  std::string GenerateSourceIR(
-      const pasta::AST &ast, const EntityMapper &em, const NameMangler &nm,
-      std::vector<mx::PackedFragmentId> fragment_ids);
-};
-
-}  // namespace indexer
diff --git a/bin/Index/Context.cpp b/bin/Index/Context.cpp
index df856c666..e56146702 100644
--- a/bin/Index/Context.cpp
+++ b/bin/Index/Context.cpp
@@ -17,7 +17,6 @@
 #include <vector>
 #include <mutex>
 
-#include "Codegen.h"
 #include "NameMangler.h"
 #include "PendingFragment.h"
 
@@ -62,8 +61,6 @@ void GlobalIndexingState::InitializeProgressBars(void) {
 
   type_progress.reset(new ProgressBar("Type serialization",
                                       report_freq));
-
-  sourceir_progress.reset(new ProgressBar("SourceIR", report_freq));
 }
 
 }  // namespace indexer
diff --git a/bin/Index/Context.h b/bin/Index/Context.h
index 113a821f3..cfc00e009 100644
--- a/bin/Index/Context.h
+++ b/bin/Index/Context.h
@@ -13,7 +13,6 @@
 #include <multiplier/Database.h>
 #include <string>
 
-#include "Codegen.h"
 #include "Executor.h"
 #include "ProgressBar.h"
 #include "Util.h"
@@ -31,7 +30,6 @@ enum class DeclKind : unsigned char;
 }  // namespace mx
 namespace indexer {
 
-class CodeGenerator;
 class GlobalIndexingState;
 class IdStore;
 class NameMangler;
@@ -67,17 +65,11 @@ class GlobalIndexingState {
   // Tracks progress in saving tokenized files.
   std::unique_ptr<ProgressBar> file_progress;
 
-  // Number of fragments for which we are attempting to generate source ir.
-  std::unique_ptr<ProgressBar> sourceir_progress;
-
   const unsigned num_workers;
 
   // Worker pool.
   Executor executor;
 
-  // MLIR code generator.
-  CodeGenerator codegen;
-
   // Write access to the index database.
   mx::DatabaseWriter &database;
 
diff --git a/bin/Index/EntityMapper.h b/bin/Index/EntityMapper.h
index dcced5fb1..1b1a27ecd 100644
--- a/bin/Index/EntityMapper.h
+++ b/bin/Index/EntityMapper.h
@@ -70,15 +70,9 @@ class EntityMapper final {
   EntityParentMap parent_decls;
   EntityParentMap parent_stmts;
 
-  // If we're in a mode where we're generating source IR then we need the
-  // entity IDs for all `Decl`s and `Stmt`s and such to be global.
-  const bool generate_source_ir;
-
-  inline explicit EntityMapper(const pasta::AST &ast_,
-                               TypeMapper &tm_, bool generate_source_ir_)
+  inline explicit EntityMapper(const pasta::AST &ast_, TypeMapper &tm_)
       : ast(ast_),
-        tm(tm_),
-        generate_source_ir(generate_source_ir_) {}
+        tm(tm_) {}
 
   mx::RawEntityId ParentDeclId(const void *) const;
   mx::RawEntityId ParentStmtId(const void *) const;
@@ -130,11 +124,7 @@ class EntityMapper final {
   }
 
   inline mx::RawEntityId SelectiveEntityId(const void *entity) const {
-    if (generate_source_ir) {
-      return EntityId(entity);
-    } else {
-      return PerFragmentEntityId(entity);
-    }
+    return PerFragmentEntityId(entity);
   }
 
   mx::RawEntityId EntityIdOfType(const void *type, uint32_t quals=0u) const;
diff --git a/bin/Index/IndexCompileJob.cpp b/bin/Index/IndexCompileJob.cpp
index 8e4be68ee..a9828f3b7 100644
--- a/bin/Index/IndexCompileJob.cpp
+++ b/bin/Index/IndexCompileJob.cpp
@@ -3341,7 +3341,7 @@ void IndexCompileJobAction::Run(void) {
       << "Built AST for main source file " << main_file_path;
 
   TypeMapper tm(ast, context.id_store);
-  EntityMapper em(ast, tm, context.codegen.IsEnabled());
+  EntityMapper em(ast, tm);
 
   PersistParsedFiles(context, ast, em);
 
diff --git a/bin/Index/Main.cpp b/bin/Index/Main.cpp
index 8c1befafb..003aa9d1b 100644
--- a/bin/Index/Main.cpp
+++ b/bin/Index/Main.cpp
@@ -69,8 +69,6 @@ DEFINE_string(workspace, "mx-workspace",
               "is stored. When you're done indexing, and if you don't plan to add any additional "
               "targets into the index, then you can delete this directory.");
 
-DEFINE_bool(generate_sourceir, false, "Generate SourceIR from the top-level declarations");
-
 DEFINE_bool(fork_mode, false, "Use --fork_mode if running inside docker");
 DEFINE_bool(reproc_mode, false, "Use --reproc_mode to use reproc library");
 
@@ -167,7 +165,6 @@ int main(int argc, char *argv[], char *envp[]) {
      << " [--num_command_workers N]\n"
      << " [--env PATH_TO_COPIED_ENV_VARS]\n"
      << " [--show_progress]\n"
-     << " [--generate_sourceir]\n"
      << " --fork_mode\n"
      << " --reproc_mode\n"
      << " --db DATABASE\n"
@@ -234,10 +231,6 @@ int main(int argc, char *argv[], char *envp[]) {
   auto fs = pasta::FileSystem::CreateNative();
   pasta::FileManager fm(fs);
 
-  if (!FLAGS_generate_sourceir) {
-    context.codegen.Disable();
-  }
-
   std::filesystem::path path(FLAGS_target);
 
   if (FLAGS_target == "/dev/stdin") {
diff --git a/bin/Index/Persist.cpp b/bin/Index/Persist.cpp
index 1745e688b..8cb6fd35e 100644
--- a/bin/Index/Persist.cpp
+++ b/bin/Index/Persist.cpp
@@ -43,7 +43,6 @@
 #include <llvm/Support/JSON.h>
 #pragma clang diagnostic pop
 
-#include "Codegen.h"
 #include "EntityMapper.h"
 #include "LabelEntitiesInFragment.h"
 #include "PASTA.h"
@@ -1123,22 +1122,6 @@ void GlobalIndexingState::PersistCompilation(
   // off all subsequent includes.
   cb.setMainFileId(em.EntityId(ast.MainFile()));
 
-  // Generate MLIR with VAST.
-  if (sourceir_progress) {
-    sourceir_progress->AddWork(1u);
-  }
-
-  if (std::string mlir = codegen.GenerateSourceIR(
-          ast, em, nm, std::move(fragment_ids));
-      !mlir.empty()) {
-    cb.setMlir(mlir);
-    if (sourceir_progress) {
-      sourceir_progress->Advance();
-    }
-  } else {
-    cb.initMlir(0u);
-  }
-
   // Add the compilation to the database.
   database.AddAsync(
       mx::CompilationRecord{tu_id.Pack(), GetSerializedData(message)});
diff --git a/bin/Index/README.md b/bin/Index/README.md
index d99c6a9eb..d7eddbd9c 100644
--- a/bin/Index/README.md
+++ b/bin/Index/README.md
@@ -7,7 +7,6 @@ The indexer, `mx-index`, is the core workhorse of Multiplier. Its job is to:
  * Partition those ASTs into fragments,
  * Identify the unique fragments,
  * Label all fragments and contained entities using their unique identifiers,
- * Generate SourceIR for newly discovered unique fragments,
  * Serialize the unique fragments.
  
 The indexer is a long-running server that also satisfies queries about the
diff --git a/bin/Index/Subprocess.cpp b/bin/Index/Subprocess.cpp
index 9e7dfed83..653955de8 100644
--- a/bin/Index/Subprocess.cpp
+++ b/bin/Index/Subprocess.cpp
@@ -8,6 +8,7 @@
 #include <glog/logging.h>
 
 #include <array>
+#include <csignal>
 #include <cstring>
 #include <errno.h>
 #include <fcntl.h>
@@ -353,11 +354,11 @@ Subprocess::Execute(const std::vector<std::string>& cmd,
   // Check if running in Docker and use fork+exec if so
   bool insideDocker = IsRunningInDocker();
   if (!FLAGS_reproc_mode) {
+    if (FLAGS_fork_mode) {
+      LOG(INFO) << "Using fork+exec (forced by --fork_mode)" << std::endl;
+      return ExecuteFork(cmd, env, input, output, error);
+    }
     if (insideDocker) {
-      if (!FLAGS_fork_mode) {
-        LOG(ERROR) << "Docker environment found. Use --fork_mode";
-        _exit(1);
-      }
       LOG(INFO) << "Executing fork+exec way for Docker environments" << std::endl;
       return ExecuteFork(cmd, env, input, output, error);
     }
diff --git a/bindings/Python/Entity.cpp b/bindings/Python/Entity.cpp
index 15f48bf43..ddc66556b 100644
--- a/bindings/Python/Entity.cpp
+++ b/bindings/Python/Entity.cpp
@@ -10,7 +10,6 @@
 #include <multiplier/Frontend/File.h>
 #include <multiplier/Frontend/Macro.h>
 #include <multiplier/Frontend/Token.h>
-#include <multiplier/IR/Operation.h>
 #include <multiplier/AST/Attr.h>
 #include <multiplier/AST/CXXBaseSpecifier.h>
 #include <multiplier/AST/CXXCtorInitializer.h>
@@ -88,7 +87,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_CONVERT_FROM_PYTHON,
                             MX_CONVERT_FROM_PYTHON,
                             MX_CONVERT_FROM_PYTHON,
                             MX_CONVERT_FROM_PYTHON,
-                            MX_CONVERT_FROM_PYTHON,
                             MX_CONVERT_FROM_PYTHON)
 #undef MX_CONVERT_FROM_PYTHON
 
@@ -109,7 +107,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_CONVERT_TO_PYTHON,
                             MX_CONVERT_TO_PYTHON,
                             MX_CONVERT_TO_PYTHON,
                             MX_CONVERT_TO_PYTHON,
-                            MX_CONVERT_TO_PYTHON,
                             MX_CONVERT_TO_PYTHON)
 #undef MX_CONVERT_TO_PYTHON
 
diff --git a/bindings/Python/Forward.h b/bindings/Python/Forward.h
index 8cf930431..3cea2d800 100644
--- a/bindings/Python/Forward.h
+++ b/bindings/Python/Forward.h
@@ -1458,697 +1458,4 @@ class IncludeMacroDirective;
 enum class IndexStatus : uint32_t;
 class Index;
 class RegexQuery;
-namespace ir {
-enum class AttributeKind : uint32_t;
-class Attribute;
-enum ValueKind : uint8_t;
-class Value;
-class Block;
-class Argument;
-class Label;
-enum class OperationKind : uint32_t;
-class Operation;
-class Result;
-class Operand;
-class Symbol;
-enum BasicBlockOrder : int32_t;
-class Region;
-enum class TypeKind : uint32_t;
-class Type;
-}  // namespace ir
-namespace ir::builtin {
-class Attribute;
-class TypedAttr;
-class ElementsAttr;
-class AffineMapAttr;
-class ArrayAttr;
-class DenseArrayAttr;
-class DenseIntOrFPElementsAttr;
-class DenseStringElementsAttr;
-class DenseResourceElementsAttr;
-class DictionaryAttr;
-class FloatAttr;
-class IntegerAttr;
-class IntegerSetAttr;
-class OpaqueAttr;
-class SparseElementsAttr;
-class StridedLayoutAttr;
-class StringAttr;
-class SymbolRefAttr;
-class TypeAttr;
-class UnitAttr;
-class BoolAttr;
-class FlatSymbolRefAttr;
-class DenseIntElementsAttr;
-class DataLayoutSpecAttr;
-class Type;
-class ShapedType;
-class FloatType;
-class ComplexType;
-class Float8E5M2Type;
-class Float8E4M3FNType;
-class Float8E5M2FNUZType;
-class Float8E4M3FNUZType;
-class Float8E4M3B11FNUZType;
-class BFloat16Type;
-class Float16Type;
-class FloatTF32Type;
-class Float32Type;
-class Float64Type;
-class Float80Type;
-class Float128Type;
-class FunctionType;
-class IndexType;
-class IntegerType;
-class MemRefType;
-class NoneType;
-class OpaqueType;
-class RankedTensorType;
-class TupleType;
-class UnrankedMemRefType;
-class UnrankedTensorType;
-class VectorType;
-class Operation;
-class ModuleOp;
-class UnrealizedConversionCastOp;
-}  // namespace ir::builtin
-namespace ir::llvm {
-class Attribute;
-class CConvAttr;
-class ComdatAttr;
-class LinkageAttr;
-class FramePointerKindAttr;
-class LoopVectorizeAttr;
-class LoopInterleaveAttr;
-class LoopUnrollAttr;
-class LoopUnrollAndJamAttr;
-class LoopLICMAttr;
-class LoopDistributeAttr;
-class LoopPipelineAttr;
-class LoopPeeledAttr;
-class LoopUnswitchAttr;
-class LoopAnnotationAttr;
-class DIExpressionElemAttr;
-class DIExpressionAttr;
-class DINullTypeAttr;
-class DIBasicTypeAttr;
-class DICompileUnitAttr;
-class DICompositeTypeAttr;
-class DIDerivedTypeAttr;
-class DIFileAttr;
-class DIGlobalVariableExpressionAttr;
-class DIGlobalVariableAttr;
-class DILexicalBlockAttr;
-class DILexicalBlockFileAttr;
-class DILocalVariableAttr;
-class DISubprogramAttr;
-class DIModuleAttr;
-class DINamespaceAttr;
-class DISubrangeAttr;
-class DISubroutineTypeAttr;
-class DILabelAttr;
-class MemoryEffectsAttr;
-class AliasScopeDomainAttr;
-class AliasScopeAttr;
-class AccessGroupAttr;
-class TBAARootAttr;
-class TBAAMemberAttr;
-class TBAATypeDescriptorAttr;
-class TBAATagAttr;
-class VScaleRangeAttr;
-class TargetFeaturesAttr;
-class IntegerOverflowFlagsAttr;
-class FastmathFlagsAttr;
-class Type;
-class ArrayType;
-class FunctionType;
-class PointerType;
-class FixedVectorType;
-class ScalableVectorType;
-class TargetExtType;
-class Operation;
-class AShrOp;
-class AddOp;
-class AddrSpaceCastOp;
-class AddressOfOp;
-class AllocaOp;
-class AndOp;
-class AtomicCmpXchgOp;
-class AtomicRMWOp;
-class BitcastOp;
-class BrOp;
-class CallIntrinsicOp;
-class CallOp;
-class ComdatOp;
-class ComdatSelectorOp;
-class CondBrOp;
-class ConstantOp;
-class ExtractElementOp;
-class ExtractValueOp;
-class FAddOp;
-class FCmpOp;
-class FDivOp;
-class FMulOp;
-class FNegOp;
-class FPExtOp;
-class FPToSIOp;
-class FPToUIOp;
-class FPTruncOp;
-class FRemOp;
-class FSubOp;
-class FenceOp;
-class FreezeOp;
-class GetElementPtrOp;
-class GlobalCtorsOp;
-class GlobalDtorsOp;
-class GlobalOp;
-class ICmpOp;
-class InlineAsmOp;
-class InsertElementOp;
-class InsertValueOp;
-class IntToPtrOp;
-class InvokeOp;
-class FuncOp;
-class LShrOp;
-class LandingpadOp;
-class LinkerOptionsOp;
-class LoadOp;
-class MulOp;
-class NoneTokenOp;
-class OrOp;
-class PoisonOp;
-class PtrToIntOp;
-class ResumeOp;
-class ReturnOp;
-class SDivOp;
-class SExtOp;
-class SIToFPOp;
-class SRemOp;
-class SelectOp;
-class ShlOp;
-class ShuffleVectorOp;
-class StoreOp;
-class SubOp;
-class SwitchOp;
-class TruncOp;
-class UDivOp;
-class UIToFPOp;
-class URemOp;
-class UndefOp;
-class UnreachableOp;
-class XOrOp;
-class ZExtOp;
-class ZeroOp;
-class AbsOp;
-class AnnotationOp;
-class AssumeOp;
-class BitReverseOp;
-class ByteSwapOp;
-class CopySignOp;
-class CoroAlignOp;
-class CoroBeginOp;
-class CoroEndOp;
-class CoroFreeOp;
-class CoroIdOp;
-class CoroPromiseOp;
-class CoroResumeOp;
-class CoroSaveOp;
-class CoroSizeOp;
-class CoroSuspendOp;
-class CosOp;
-class CountLeadingZerosOp;
-class CountTrailingZerosOp;
-class CtPopOp;
-class DbgDeclareOp;
-class DbgLabelOp;
-class DbgValueOp;
-class DebugTrapOp;
-class EhTypeidForOp;
-class Exp2Op;
-class ExpOp;
-class ExpectOp;
-class ExpectWithProbabilityOp;
-class FAbsOp;
-class FCeilOp;
-class FFloorOp;
-class FMAOp;
-class FMulAddOp;
-class FTruncOp;
-class FShlOp;
-class FShrOp;
-class GetActiveLaneMaskOp;
-class InvariantEndOp;
-class InvariantStartOp;
-class IsConstantOp;
-class IsFPClassOp;
-class LifetimeEndOp;
-class LifetimeStartOp;
-class RoundAndCastToLongLongOp;
-class RoundAndCastToNearestLongLongOp;
-class Log10Op;
-class Log2Op;
-class LogOp;
-class RoundAndCastToLongOp;
-class RoundAndCastToNearestLongOp;
-class MaskedLoadOp;
-class MaskedStoreOp;
-class MatrixColumnMajorLoadOp;
-class MatrixColumnMajorStoreOp;
-class MatrixMultiplyOp;
-class MatrixTransposeOp;
-class MaxNumOp;
-class MaximumOp;
-class MemcpyInlineOp;
-class MemcpyOp;
-class MemmoveOp;
-class MemsetOp;
-class MinNumOp;
-class MinimumOp;
-class RoundToNearbyIntOp;
-class NoAliasScopeDeclOp;
-class PowIOp;
-class FPowOp;
-class PrefetchOp;
-class PtrAnnotationOp;
-class RoundToIntOp;
-class RoundToNearestEvenOp;
-class RoundToNearestOp;
-class SAddSatOp;
-class SAddWithOverflowOp;
-class SMaxOp;
-class SMinOp;
-class SMulWithOverflowOp;
-class SSACopyOp;
-class SShlSatOp;
-class SSubSatOp;
-class SSubWithOverflowOp;
-class SinOp;
-class SqrtOp;
-class StackRestoreOp;
-class StackSaveOp;
-class StepVectorOp;
-class ThreadLocalAddressOp;
-class TrapOp;
-class UAddSatOp;
-class UAddWithOverflowOp;
-class UBSanTrapOp;
-class UMaxOp;
-class UMinOp;
-class UMulWithOverflowOp;
-class UShlSatOp;
-class USubSatOp;
-class USubWithOverflowOp;
-class VPAShrOp;
-class VPAddOp;
-class VPAndOp;
-class VPFAddOp;
-class VPFDivOp;
-class VPFMulAddOp;
-class VPFMulOp;
-class VPFNegOp;
-class VPFPExtOp;
-class VPFPToSIOp;
-class VPFPToUIOp;
-class VPFPTruncOp;
-class VPFRemOp;
-class VPFSubOp;
-class VPFmaOp;
-class VPIntToPtrOp;
-class VPLShrOp;
-class VPLoadOp;
-class VPMergeMinOp;
-class VPMulOp;
-class VPOrOp;
-class VPPtrToIntOp;
-class VPReduceAddOp;
-class VPReduceAndOp;
-class VPReduceFAddOp;
-class VPReduceFMaxOp;
-class VPReduceFMinOp;
-class VPReduceFMulOp;
-class VPReduceMulOp;
-class VPReduceOrOp;
-class VPReduceSMaxOp;
-class VPReduceSMinOp;
-class VPReduceUMaxOp;
-class VPReduceUMinOp;
-class VPReduceXorOp;
-class VPSDivOp;
-class VPSExtOp;
-class VPSIToFPOp;
-class VPSRemOp;
-class VPSelectMinOp;
-class VPShlOp;
-class VPStoreOp;
-class VPStridedLoadOp;
-class VPStridedStoreOp;
-class VPSubOp;
-class VPTruncOp;
-class VPUDivOp;
-class VPUIToFPOp;
-class VPURemOp;
-class VPXorOp;
-class VPZExtOp;
-class VaCopyOp;
-class VaEndOp;
-class VaStartOp;
-class VarAnnotationOp;
-class MaskedCompressStoreOp;
-class MaskedExpandLoadOp;
-class MaskedGatherOp;
-class MaskedScatterOp;
-class VectorExtractOp;
-class VectorInsertOp;
-class VectorReduceAddOp;
-class VectorReduceAndOp;
-class VectorReduceFAddOp;
-class VectorReduceFMaxOp;
-class VectorReduceFMaximumOp;
-class VectorReduceFMinOp;
-class VectorReduceFMinimumOp;
-class VectorReduceFMulOp;
-class VectorReduceMulOp;
-class VectorReduceOrOp;
-class VectorReduceSMaxOp;
-class VectorReduceSMinOp;
-class VectorReduceUMaxOp;
-class VectorReduceUMinOp;
-class VectorReduceXorOp;
-class VScaleOp;
-}  // namespace ir::llvm
-namespace ir::memref {
-class Operation;
-class AssumeAlignmentOp;
-class AtomicRMWOp;
-class AtomicYieldOp;
-class CopyOp;
-class GenericAtomicRMWOp;
-class LoadOp;
-class AllocOp;
-class AllocaOp;
-class AllocaScopeOp;
-class AllocaScopeReturnOp;
-class CastOp;
-class CollapseShapeOp;
-class DeallocOp;
-class DimOp;
-class DMAStartOp;
-class DMAWaitOp;
-class ExpandShapeOp;
-class ExtractAlignedPointerAsIndexOp;
-class ExtractStridedMetadataOp;
-class GetGlobalOp;
-class GlobalOp;
-class MemorySpaceCastOp;
-class PrefetchOp;
-class RankOp;
-class ReallocOp;
-class ReinterpretCastOp;
-class ReshapeOp;
-class StoreOp;
-class TransposeOp;
-class ViewOp;
-class SubViewOp;
-}  // namespace ir::memref
-namespace ir::abi {
-class Operation;
-class CallArgsOp;
-class CallExecutionOp;
-class CallOp;
-class CallRetsOp;
-class DirectOp;
-class EpilogueOp;
-class FuncOp;
-class IndirectOp;
-class PrologueOp;
-class RetDirectOp;
-class YieldOp;
-}  // namespace ir::abi
-namespace ir::ll {
-class Operation;
-class AllocaOp;
-class ArgAllocaOp;
-class BrOp;
-class ConcatOp;
-class CondBrOp;
-class CondScopeRetOp;
-class ExtractOp;
-class InitializeVarOp;
-class InlineScopeOp;
-class LoadOp;
-class FuncOp;
-class StructGEPOp;
-class ReturnOp;
-class ScopeOp;
-class ScopeRecurseOp;
-class ScopeRetOp;
-class StoreOp;
-class SubscriptOp;
-class UninitializedVarOp;
-}  // namespace ir::ll
-namespace ir::hl {
-class Attribute;
-class AnnotationAttr;
-class FormatAttr;
-class SectionAttr;
-class AliasAttr;
-class ErrorAttr;
-class CountedByAttr;
-class CleanupAttr;
-class AlignedAttr;
-class AlwaysInlineAttr;
-class NoInlineAttr;
-class ConstAttr;
-class LoaderUninitializedAttr;
-class NoInstrumentFunctionAttr;
-class PackedAttr;
-class PureAttr;
-class WarnUnusedResultAttr;
-class RestrictAttr;
-class NoThrowAttr;
-class NonNullAttr;
-class LeafAttr;
-class ColdAttr;
-class TransparentUnionAttr;
-class ReturnsTwiceAttr;
-class MayAliasAttr;
-class UnusedAttr;
-class UsedAttr;
-class GNUInlineAttr;
-class NoCfCheckAttr;
-class AvailableOnlyInDefaultEvalMethodAttr;
-class AvailabilityAttrAttr;
-class FallthroughAttr;
-class NoProfileInstrumentFunctionAttr;
-class AsmLabelAttr;
-class ModeAttr;
-class BuiltinAttr;
-class AllocAlignAttr;
-class AllocSizeAttr;
-class DeprecatedAttr;
-class MaxFieldAlignmentAttr;
-class VisibilityAttr;
-class AssumeAlignedAttr;
-class CVQualifiersAttr;
-class UCVQualifiersAttr;
-class CVRQualifiersAttr;
-class OffsetOfNodeAttr;
-class Type;
-class RecordType;
-class EnumType;
-class TypedefType;
-class ElaboratedType;
-class LabelType;
-class ParenType;
-class LValueType;
-class RValueType;
-class VoidType;
-class BoolType;
-class CharType;
-class ShortType;
-class IntType;
-class LongType;
-class LongLongType;
-class Int128Type;
-class HalfType;
-class BFloat16Type;
-class FloatType;
-class DoubleType;
-class LongDoubleType;
-class Float128Type;
-class ComplexType;
-class PointerType;
-class ArrayType;
-class VectorType;
-class DecayedType;
-class AttributedType;
-class AdjustedType;
-class ReferenceType;
-class TypeOfExprType;
-class TypeOfTypeType;
-class AutoType;
-class AtomicType;
-class Operation;
-class RefOp;
-class AccessSpecifierOp;
-class AddFAssignOp;
-class AddFOp;
-class AddIAssignOp;
-class AddIOp;
-class AddrLabelExprOp;
-class AddressOfOp;
-class AlignOfExprOp;
-class AlignOfTypeOp;
-class AsmOp;
-class AssignOp;
-class AttributedStmtOp;
-class BinAShrAssignOp;
-class BinAShrOp;
-class BinAndAssignOp;
-class BinAndOp;
-class BinCommaOp;
-class BinLAndOp;
-class BinLOrOp;
-class BinLShrAssignOp;
-class BinLShrOp;
-class BinOrAssignOp;
-class BinOrOp;
-class BinShlAssignOp;
-class BinShlOp;
-class BinXorAssignOp;
-class BinXorOp;
-class BinaryCondOp;
-class BreakOp;
-class BuiltinBitCastOp;
-class BuiltinTypesCompatiblePOp;
-class CStyleCastOp;
-class CallOp;
-class CaseOp;
-class ChooseExprOp;
-class ClassDeclOp;
-class CmpOp;
-class CompoundLiteralOp;
-class CondOp;
-class CondYieldOp;
-class ConstantOp;
-class ContinueOp;
-class CxxBaseSpecifierOp;
-class CxxStructDeclOp;
-class DeclRefOp;
-class DefaultOp;
-class DerefOp;
-class DivFAssignOp;
-class DivFOp;
-class DivSAssignOp;
-class DivSOp;
-class DivUAssignOp;
-class DivUOp;
-class DoOp;
-class EmptyDeclOp;
-class EnumConstantOp;
-class EnumDeclOp;
-class EnumRefOp;
-class ExprOp;
-class ExtensionOp;
-class FCmpOp;
-class FieldDeclOp;
-class FileScopeAsmOp;
-class ForOp;
-class FuncOp;
-class FuncRefOp;
-class GenericAssocExprOp;
-class GenericSelectionExprOp;
-class GlobalRefOp;
-class GotoStmtOp;
-class IfOp;
-class ImagOp;
-class ImplicitCastOp;
-class IndirectCallOp;
-class IndirectGotoStmtOp;
-class InitListExprOp;
-class InitializedConstantOp;
-class LNotOp;
-class LabelDeclOp;
-class LabelStmtOp;
-class MinusOp;
-class MulFAssignOp;
-class MulFOp;
-class MulIAssignOp;
-class MulIOp;
-class NotOp;
-class NullStmtOp;
-class OffsetOfExprOp;
-class OpaqueValueExprOp;
-class PlusOp;
-class PostDecOp;
-class PostIncOp;
-class PreDecOp;
-class PreIncOp;
-class PredefinedExprOp;
-class PreferredAlignOfExprOp;
-class PreferredAlignOfTypeOp;
-class RealOp;
-class RecordMemberOp;
-class RemFAssignOp;
-class RemFOp;
-class RemSAssignOp;
-class RemSOp;
-class RemUAssignOp;
-class RemUOp;
-class ReturnOp;
-class SizeOfExprOp;
-class SizeOfTypeOp;
-class StaticAssertDeclOp;
-class StmtExprOp;
-class StructDeclOp;
-class SubFAssignOp;
-class SubFOp;
-class SubIAssignOp;
-class SubIOp;
-class SubscriptOp;
-class SwitchOp;
-class ThisOp;
-class TranslationUnitOp;
-class TypeAliasOp;
-class TypeDeclOp;
-class TypeDefOp;
-class TypeOfExprOp;
-class TypeYieldOp;
-class UnionDeclOp;
-class UnreachableOp;
-class VAArgExprOp;
-class ValueYieldOp;
-class VarDeclOp;
-class WhileOp;
-}  // namespace ir::hl
-namespace ir::core {
-class Attribute;
-class BooleanAttr;
-class IntegerAttr;
-class FloatAttr;
-class VoidAttr;
-class SourceLanguageAttr;
-class GlobalLinkageKindAttr;
-class Type;
-class FunctionType;
-class Operation;
-class BinLAndOp;
-class BinLOrOp;
-class ImplicitReturnOp;
-class LazyOp;
-class ModuleOp;
-class ScopeOp;
-class SelectOp;
-}  // namespace ir::core
-namespace ir::meta {
-class Attribute;
-class IdentifierAttr;
-}  // namespace ir::meta
-namespace ir::unsup {
-class Type;
-class UnsupportedType;
-class Operation;
-class UnsupportedDeclOp;
-class UnsupportedStmtOp;
-}  // namespace ir::unsup
 }  // namespace mx
diff --git a/bindings/Python/Generated/AST/AArch64SVEPcsAttr.cpp b/bindings/Python/Generated/AST/AArch64SVEPcsAttr.cpp
index f40e191d3..dd7bd65d9 100644
--- a/bindings/Python/Generated/AST/AArch64SVEPcsAttr.cpp
+++ b/bindings/Python/Generated/AST/AArch64SVEPcsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AArch64VectorPcsAttr.cpp b/bindings/Python/Generated/AST/AArch64VectorPcsAttr.cpp
index f166a85b9..42e3e451c 100644
--- a/bindings/Python/Generated/AST/AArch64VectorPcsAttr.cpp
+++ b/bindings/Python/Generated/AST/AArch64VectorPcsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AMDGPUFlatWorkGroupSizeAttr.cpp b/bindings/Python/Generated/AST/AMDGPUFlatWorkGroupSizeAttr.cpp
index 0d06021ac..d00693385 100644
--- a/bindings/Python/Generated/AST/AMDGPUFlatWorkGroupSizeAttr.cpp
+++ b/bindings/Python/Generated/AST/AMDGPUFlatWorkGroupSizeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AMDGPUKernelCallAttr.cpp b/bindings/Python/Generated/AST/AMDGPUKernelCallAttr.cpp
index d4ab98a6f..373280da8 100644
--- a/bindings/Python/Generated/AST/AMDGPUKernelCallAttr.cpp
+++ b/bindings/Python/Generated/AST/AMDGPUKernelCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AMDGPUNumSGPRAttr.cpp b/bindings/Python/Generated/AST/AMDGPUNumSGPRAttr.cpp
index 8740149fb..7c3a4bd69 100644
--- a/bindings/Python/Generated/AST/AMDGPUNumSGPRAttr.cpp
+++ b/bindings/Python/Generated/AST/AMDGPUNumSGPRAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AMDGPUNumVGPRAttr.cpp b/bindings/Python/Generated/AST/AMDGPUNumVGPRAttr.cpp
index a81baed5a..269da0623 100644
--- a/bindings/Python/Generated/AST/AMDGPUNumVGPRAttr.cpp
+++ b/bindings/Python/Generated/AST/AMDGPUNumVGPRAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AMDGPUWavesPerEUAttr.cpp b/bindings/Python/Generated/AST/AMDGPUWavesPerEUAttr.cpp
index 59052498f..65ece675e 100644
--- a/bindings/Python/Generated/AST/AMDGPUWavesPerEUAttr.cpp
+++ b/bindings/Python/Generated/AST/AMDGPUWavesPerEUAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ARMInterruptAttr.cpp b/bindings/Python/Generated/AST/ARMInterruptAttr.cpp
index 00a032139..c0677b8b1 100644
--- a/bindings/Python/Generated/AST/ARMInterruptAttr.cpp
+++ b/bindings/Python/Generated/AST/ARMInterruptAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AVRInterruptAttr.cpp b/bindings/Python/Generated/AST/AVRInterruptAttr.cpp
index 574640387..39322bd80 100644
--- a/bindings/Python/Generated/AST/AVRInterruptAttr.cpp
+++ b/bindings/Python/Generated/AST/AVRInterruptAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AVRSignalAttr.cpp b/bindings/Python/Generated/AST/AVRSignalAttr.cpp
index 6a25e662e..91e786465 100644
--- a/bindings/Python/Generated/AST/AVRSignalAttr.cpp
+++ b/bindings/Python/Generated/AST/AVRSignalAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AbiTagAttr.cpp b/bindings/Python/Generated/AST/AbiTagAttr.cpp
index 6b24d8718..a8d40bd60 100644
--- a/bindings/Python/Generated/AST/AbiTagAttr.cpp
+++ b/bindings/Python/Generated/AST/AbiTagAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AbstractConditionalOperator.cpp b/bindings/Python/Generated/AST/AbstractConditionalOperator.cpp
index 7ccfe5311..8f76d09d3 100644
--- a/bindings/Python/Generated/AST/AbstractConditionalOperator.cpp
+++ b/bindings/Python/Generated/AST/AbstractConditionalOperator.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -282,18 +281,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::AbstractConditionalOperator::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::AbstractConditionalOperator::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::AbstractConditionalOperator::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -319,7 +356,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -342,52 +379,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AbstractConditionalOperator::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::AbstractConditionalOperator::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::AbstractConditionalOperator::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/AccessSpecDecl.cpp b/bindings/Python/Generated/AST/AccessSpecDecl.cpp
index acae1730a..1eeafff21 100644
--- a/bindings/Python/Generated/AST/AccessSpecDecl.cpp
+++ b/bindings/Python/Generated/AST/AccessSpecDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AccessSpecDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::AccessSpecDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AccessSpecDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::AccessSpecDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/AcquireCapabilityAttr.cpp b/bindings/Python/Generated/AST/AcquireCapabilityAttr.cpp
index 7685f97d8..e7e1aa481 100644
--- a/bindings/Python/Generated/AST/AcquireCapabilityAttr.cpp
+++ b/bindings/Python/Generated/AST/AcquireCapabilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AcquireHandleAttr.cpp b/bindings/Python/Generated/AST/AcquireHandleAttr.cpp
index f28801c31..693db115d 100644
--- a/bindings/Python/Generated/AST/AcquireHandleAttr.cpp
+++ b/bindings/Python/Generated/AST/AcquireHandleAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AcquiredAfterAttr.cpp b/bindings/Python/Generated/AST/AcquiredAfterAttr.cpp
index f9043650b..17d699308 100644
--- a/bindings/Python/Generated/AST/AcquiredAfterAttr.cpp
+++ b/bindings/Python/Generated/AST/AcquiredAfterAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AcquiredBeforeAttr.cpp b/bindings/Python/Generated/AST/AcquiredBeforeAttr.cpp
index ae8a35309..9f0adbc8c 100644
--- a/bindings/Python/Generated/AST/AcquiredBeforeAttr.cpp
+++ b/bindings/Python/Generated/AST/AcquiredBeforeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AddrLabelExpr.cpp b/bindings/Python/Generated/AST/AddrLabelExpr.cpp
index 5cecbe400..88d35747d 100644
--- a/bindings/Python/Generated/AST/AddrLabelExpr.cpp
+++ b/bindings/Python/Generated/AST/AddrLabelExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AddrLabelExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::AddrLabelExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AddrLabelExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::AddrLabelExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/AddressSpaceAttr.cpp b/bindings/Python/Generated/AST/AddressSpaceAttr.cpp
index 8480f26b1..aa291179b 100644
--- a/bindings/Python/Generated/AST/AddressSpaceAttr.cpp
+++ b/bindings/Python/Generated/AST/AddressSpaceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AdjustedType.cpp b/bindings/Python/Generated/AST/AdjustedType.cpp
index bf9fff3b0..4d82b0c2e 100644
--- a/bindings/Python/Generated/AST/AdjustedType.cpp
+++ b/bindings/Python/Generated/AST/AdjustedType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -298,7 +297,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AliasAttr.cpp b/bindings/Python/Generated/AST/AliasAttr.cpp
index 6160a1cdc..9059075e5 100644
--- a/bindings/Python/Generated/AST/AliasAttr.cpp
+++ b/bindings/Python/Generated/AST/AliasAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AlignMac68kAttr.cpp b/bindings/Python/Generated/AST/AlignMac68kAttr.cpp
index 2b23fcfbf..653898b9a 100644
--- a/bindings/Python/Generated/AST/AlignMac68kAttr.cpp
+++ b/bindings/Python/Generated/AST/AlignMac68kAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AlignNaturalAttr.cpp b/bindings/Python/Generated/AST/AlignNaturalAttr.cpp
index 9a0909393..639d61edb 100644
--- a/bindings/Python/Generated/AST/AlignNaturalAttr.cpp
+++ b/bindings/Python/Generated/AST/AlignNaturalAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AlignValueAttr.cpp b/bindings/Python/Generated/AST/AlignValueAttr.cpp
index d69ccb55c..330d1afe0 100644
--- a/bindings/Python/Generated/AST/AlignValueAttr.cpp
+++ b/bindings/Python/Generated/AST/AlignValueAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AlignedAttr.cpp b/bindings/Python/Generated/AST/AlignedAttr.cpp
index 59fdff700..a3c7b0a14 100644
--- a/bindings/Python/Generated/AST/AlignedAttr.cpp
+++ b/bindings/Python/Generated/AST/AlignedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -400,7 +399,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AllocAlignAttr.cpp b/bindings/Python/Generated/AST/AllocAlignAttr.cpp
index de83ed4c6..8d66dab85 100644
--- a/bindings/Python/Generated/AST/AllocAlignAttr.cpp
+++ b/bindings/Python/Generated/AST/AllocAlignAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AllocSizeAttr.cpp b/bindings/Python/Generated/AST/AllocSizeAttr.cpp
index 7651e28a5..ca175b29b 100644
--- a/bindings/Python/Generated/AST/AllocSizeAttr.cpp
+++ b/bindings/Python/Generated/AST/AllocSizeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AlwaysDestroyAttr.cpp b/bindings/Python/Generated/AST/AlwaysDestroyAttr.cpp
index 8ff23a59f..a4f6faf86 100644
--- a/bindings/Python/Generated/AST/AlwaysDestroyAttr.cpp
+++ b/bindings/Python/Generated/AST/AlwaysDestroyAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AlwaysInlineAttr.cpp b/bindings/Python/Generated/AST/AlwaysInlineAttr.cpp
index 08be91a79..e00f1d268 100644
--- a/bindings/Python/Generated/AST/AlwaysInlineAttr.cpp
+++ b/bindings/Python/Generated/AST/AlwaysInlineAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AnalyzerNoReturnAttr.cpp b/bindings/Python/Generated/AST/AnalyzerNoReturnAttr.cpp
index 1f2c23e6b..eb56d49bf 100644
--- a/bindings/Python/Generated/AST/AnalyzerNoReturnAttr.cpp
+++ b/bindings/Python/Generated/AST/AnalyzerNoReturnAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AnnotateAttr.cpp b/bindings/Python/Generated/AST/AnnotateAttr.cpp
index a8a11f78c..12c7fe4aa 100644
--- a/bindings/Python/Generated/AST/AnnotateAttr.cpp
+++ b/bindings/Python/Generated/AST/AnnotateAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AnnotateTypeAttr.cpp b/bindings/Python/Generated/AST/AnnotateTypeAttr.cpp
index c4bca95c5..5cb07ce27 100644
--- a/bindings/Python/Generated/AST/AnnotateTypeAttr.cpp
+++ b/bindings/Python/Generated/AST/AnnotateTypeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AnyX86InterruptAttr.cpp b/bindings/Python/Generated/AST/AnyX86InterruptAttr.cpp
index d0c6a7ef7..75ea402e1 100644
--- a/bindings/Python/Generated/AST/AnyX86InterruptAttr.cpp
+++ b/bindings/Python/Generated/AST/AnyX86InterruptAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AnyX86NoCallerSavedRegistersAttr.cpp b/bindings/Python/Generated/AST/AnyX86NoCallerSavedRegistersAttr.cpp
index eb0ff31f5..a7986dfad 100644
--- a/bindings/Python/Generated/AST/AnyX86NoCallerSavedRegistersAttr.cpp
+++ b/bindings/Python/Generated/AST/AnyX86NoCallerSavedRegistersAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AnyX86NoCfCheckAttr.cpp b/bindings/Python/Generated/AST/AnyX86NoCfCheckAttr.cpp
index 570494528..13ab7536c 100644
--- a/bindings/Python/Generated/AST/AnyX86NoCfCheckAttr.cpp
+++ b/bindings/Python/Generated/AST/AnyX86NoCfCheckAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArcWeakrefUnavailableAttr.cpp b/bindings/Python/Generated/AST/ArcWeakrefUnavailableAttr.cpp
index 69dd14417..23c1a26c2 100644
--- a/bindings/Python/Generated/AST/ArcWeakrefUnavailableAttr.cpp
+++ b/bindings/Python/Generated/AST/ArcWeakrefUnavailableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArgumentWithTypeTagAttr.cpp b/bindings/Python/Generated/AST/ArgumentWithTypeTagAttr.cpp
index a717a0b4d..a1a2abd2c 100644
--- a/bindings/Python/Generated/AST/ArgumentWithTypeTagAttr.cpp
+++ b/bindings/Python/Generated/AST/ArgumentWithTypeTagAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmBuiltinAliasAttr.cpp b/bindings/Python/Generated/AST/ArmBuiltinAliasAttr.cpp
index febaea32e..5bcdbecdc 100644
--- a/bindings/Python/Generated/AST/ArmBuiltinAliasAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmBuiltinAliasAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmInAttr.cpp b/bindings/Python/Generated/AST/ArmInAttr.cpp
index 908679701..978c2a8f3 100644
--- a/bindings/Python/Generated/AST/ArmInAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmInAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmInOutAttr.cpp b/bindings/Python/Generated/AST/ArmInOutAttr.cpp
index cc08aa0d3..8f4f2cae9 100644
--- a/bindings/Python/Generated/AST/ArmInOutAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmInOutAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmLocallyStreamingAttr.cpp b/bindings/Python/Generated/AST/ArmLocallyStreamingAttr.cpp
index cff894412..54d450b36 100644
--- a/bindings/Python/Generated/AST/ArmLocallyStreamingAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmLocallyStreamingAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmMveStrictPolymorphismAttr.cpp b/bindings/Python/Generated/AST/ArmMveStrictPolymorphismAttr.cpp
index 2fe3bc7de..8ee8663c5 100644
--- a/bindings/Python/Generated/AST/ArmMveStrictPolymorphismAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmMveStrictPolymorphismAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmNewAttr.cpp b/bindings/Python/Generated/AST/ArmNewAttr.cpp
index 8359c53ee..1f0370d18 100644
--- a/bindings/Python/Generated/AST/ArmNewAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmNewAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmOutAttr.cpp b/bindings/Python/Generated/AST/ArmOutAttr.cpp
index 0531db170..39dfa80f5 100644
--- a/bindings/Python/Generated/AST/ArmOutAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmOutAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmPreservesAttr.cpp b/bindings/Python/Generated/AST/ArmPreservesAttr.cpp
index 967aad3e7..4481459bf 100644
--- a/bindings/Python/Generated/AST/ArmPreservesAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmPreservesAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmStreamingAttr.cpp b/bindings/Python/Generated/AST/ArmStreamingAttr.cpp
index 2129098b1..da733a7a4 100644
--- a/bindings/Python/Generated/AST/ArmStreamingAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmStreamingAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArmStreamingCompatibleAttr.cpp b/bindings/Python/Generated/AST/ArmStreamingCompatibleAttr.cpp
index cbe0264c2..c844f9fa3 100644
--- a/bindings/Python/Generated/AST/ArmStreamingCompatibleAttr.cpp
+++ b/bindings/Python/Generated/AST/ArmStreamingCompatibleAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArrayInitIndexExpr.cpp b/bindings/Python/Generated/AST/ArrayInitIndexExpr.cpp
index 77224a511..c80ec4b3d 100644
--- a/bindings/Python/Generated/AST/ArrayInitIndexExpr.cpp
+++ b/bindings/Python/Generated/AST/ArrayInitIndexExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ArrayInitIndexExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ArrayInitIndexExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ArrayInitIndexExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ArrayInitIndexExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ArrayInitLoopExpr.cpp b/bindings/Python/Generated/AST/ArrayInitLoopExpr.cpp
index 0abe6b81f..8aa7490df 100644
--- a/bindings/Python/Generated/AST/ArrayInitLoopExpr.cpp
+++ b/bindings/Python/Generated/AST/ArrayInitLoopExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ArrayInitLoopExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ArrayInitLoopExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ArrayInitLoopExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ArrayInitLoopExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ArraySubscriptExpr.cpp b/bindings/Python/Generated/AST/ArraySubscriptExpr.cpp
index dbbd31fa7..c20d73c49 100644
--- a/bindings/Python/Generated/AST/ArraySubscriptExpr.cpp
+++ b/bindings/Python/Generated/AST/ArraySubscriptExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ArraySubscriptExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ArraySubscriptExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ArraySubscriptExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ArraySubscriptExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ArrayType.cpp b/bindings/Python/Generated/AST/ArrayType.cpp
index 9f18099d7..8ad04273f 100644
--- a/bindings/Python/Generated/AST/ArrayType.cpp
+++ b/bindings/Python/Generated/AST/ArrayType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -289,7 +288,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ArrayTypeTraitExpr.cpp b/bindings/Python/Generated/AST/ArrayTypeTraitExpr.cpp
index 422346151..89c739ef6 100644
--- a/bindings/Python/Generated/AST/ArrayTypeTraitExpr.cpp
+++ b/bindings/Python/Generated/AST/ArrayTypeTraitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ArrayTypeTraitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ArrayTypeTraitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ArrayTypeTraitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ArrayTypeTraitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ArtificialAttr.cpp b/bindings/Python/Generated/AST/ArtificialAttr.cpp
index ea978013a..0be84672e 100644
--- a/bindings/Python/Generated/AST/ArtificialAttr.cpp
+++ b/bindings/Python/Generated/AST/ArtificialAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AsTypeExpr.cpp b/bindings/Python/Generated/AST/AsTypeExpr.cpp
index 042bed2a9..be16dd38e 100644
--- a/bindings/Python/Generated/AST/AsTypeExpr.cpp
+++ b/bindings/Python/Generated/AST/AsTypeExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AsTypeExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::AsTypeExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AsTypeExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::AsTypeExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/AsmLabelAttr.cpp b/bindings/Python/Generated/AST/AsmLabelAttr.cpp
index 85e0377ed..aedde84fd 100644
--- a/bindings/Python/Generated/AST/AsmLabelAttr.cpp
+++ b/bindings/Python/Generated/AST/AsmLabelAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AsmStmt.cpp b/bindings/Python/Generated/AST/AsmStmt.cpp
index 635826302..c33143da2 100644
--- a/bindings/Python/Generated/AST/AsmStmt.cpp
+++ b/bindings/Python/Generated/AST/AsmStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -382,18 +381,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::AsmStmt::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::AsmStmt::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::AsmStmt::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -419,7 +456,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -442,52 +479,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AsmStmt::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::AsmStmt::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::AsmStmt::from_base"),
-  },
   {
     "nth_input",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/AssertCapabilityAttr.cpp b/bindings/Python/Generated/AST/AssertCapabilityAttr.cpp
index 1c45e1063..755fce32c 100644
--- a/bindings/Python/Generated/AST/AssertCapabilityAttr.cpp
+++ b/bindings/Python/Generated/AST/AssertCapabilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AssertExclusiveLockAttr.cpp b/bindings/Python/Generated/AST/AssertExclusiveLockAttr.cpp
index 9ff51bfa8..0b58f21cb 100644
--- a/bindings/Python/Generated/AST/AssertExclusiveLockAttr.cpp
+++ b/bindings/Python/Generated/AST/AssertExclusiveLockAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AssertSharedLockAttr.cpp b/bindings/Python/Generated/AST/AssertSharedLockAttr.cpp
index f4a73143e..da1169cb2 100644
--- a/bindings/Python/Generated/AST/AssertSharedLockAttr.cpp
+++ b/bindings/Python/Generated/AST/AssertSharedLockAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AssumeAlignedAttr.cpp b/bindings/Python/Generated/AST/AssumeAlignedAttr.cpp
index d458461b8..6087cecc5 100644
--- a/bindings/Python/Generated/AST/AssumeAlignedAttr.cpp
+++ b/bindings/Python/Generated/AST/AssumeAlignedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AssumptionAttr.cpp b/bindings/Python/Generated/AST/AssumptionAttr.cpp
index 1c3b2856f..8f412fd46 100644
--- a/bindings/Python/Generated/AST/AssumptionAttr.cpp
+++ b/bindings/Python/Generated/AST/AssumptionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AtomicExpr.cpp b/bindings/Python/Generated/AST/AtomicExpr.cpp
index 32e61d256..8b2166eac 100644
--- a/bindings/Python/Generated/AST/AtomicExpr.cpp
+++ b/bindings/Python/Generated/AST/AtomicExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -397,67 +396,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AtomicExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::AtomicExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -521,6 +459,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AtomicExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::AtomicExpr::from"),
+  },
   {
     "nth_sub_expression",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/AtomicType.cpp b/bindings/Python/Generated/AST/AtomicType.cpp
index 46a1b337e..3477bb191 100644
--- a/bindings/Python/Generated/AST/AtomicType.cpp
+++ b/bindings/Python/Generated/AST/AtomicType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/Attr.cpp b/bindings/Python/Generated/AST/Attr.cpp
index 04defe1fb..bba4c3770 100644
--- a/bindings/Python/Generated/AST/Attr.cpp
+++ b/bindings/Python/Generated/AST/Attr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -1975,7 +1974,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AttributedStmt.cpp b/bindings/Python/Generated/AST/AttributedStmt.cpp
index 4a21e4b33..a4e5df749 100644
--- a/bindings/Python/Generated/AST/AttributedStmt.cpp
+++ b/bindings/Python/Generated/AST/AttributedStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AttributedStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::AttributedStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::AttributedStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::AttributedStmt::from"),
+  },
   {
     "nth_attribute",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/AttributedType.cpp b/bindings/Python/Generated/AST/AttributedType.cpp
index 64c33418f..a820c56fd 100644
--- a/bindings/Python/Generated/AST/AttributedType.cpp
+++ b/bindings/Python/Generated/AST/AttributedType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -374,7 +373,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AutoType.cpp b/bindings/Python/Generated/AST/AutoType.cpp
index 3dfef69a8..ba4a2ca1e 100644
--- a/bindings/Python/Generated/AST/AutoType.cpp
+++ b/bindings/Python/Generated/AST/AutoType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -334,7 +333,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AvailabilityAttr.cpp b/bindings/Python/Generated/AST/AvailabilityAttr.cpp
index 1ed2dc696..c6bc03c2f 100644
--- a/bindings/Python/Generated/AST/AvailabilityAttr.cpp
+++ b/bindings/Python/Generated/AST/AvailabilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -340,7 +339,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/AvailableOnlyInDefaultEvalMethodAttr.cpp b/bindings/Python/Generated/AST/AvailableOnlyInDefaultEvalMethodAttr.cpp
index 3932294c6..8c173a777 100644
--- a/bindings/Python/Generated/AST/AvailableOnlyInDefaultEvalMethodAttr.cpp
+++ b/bindings/Python/Generated/AST/AvailableOnlyInDefaultEvalMethodAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BPFPreserveAccessIndexAttr.cpp b/bindings/Python/Generated/AST/BPFPreserveAccessIndexAttr.cpp
index f44b2d5f5..b90ad2465 100644
--- a/bindings/Python/Generated/AST/BPFPreserveAccessIndexAttr.cpp
+++ b/bindings/Python/Generated/AST/BPFPreserveAccessIndexAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BPFPreserveStaticOffsetAttr.cpp b/bindings/Python/Generated/AST/BPFPreserveStaticOffsetAttr.cpp
index 67a0fdec9..3143083ff 100644
--- a/bindings/Python/Generated/AST/BPFPreserveStaticOffsetAttr.cpp
+++ b/bindings/Python/Generated/AST/BPFPreserveStaticOffsetAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BTFDeclTagAttr.cpp b/bindings/Python/Generated/AST/BTFDeclTagAttr.cpp
index 090179546..20825c7ce 100644
--- a/bindings/Python/Generated/AST/BTFDeclTagAttr.cpp
+++ b/bindings/Python/Generated/AST/BTFDeclTagAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BTFTagAttributedType.cpp b/bindings/Python/Generated/AST/BTFTagAttributedType.cpp
index 499cfbe05..8cba9f0fd 100644
--- a/bindings/Python/Generated/AST/BTFTagAttributedType.cpp
+++ b/bindings/Python/Generated/AST/BTFTagAttributedType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BTFTypeTagAttr.cpp b/bindings/Python/Generated/AST/BTFTypeTagAttr.cpp
index 5b4a1917f..fd7e3281e 100644
--- a/bindings/Python/Generated/AST/BTFTypeTagAttr.cpp
+++ b/bindings/Python/Generated/AST/BTFTypeTagAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BaseUsingDecl.cpp b/bindings/Python/Generated/AST/BaseUsingDecl.cpp
index 16bb563d5..c588c7bcc 100644
--- a/bindings/Python/Generated/AST/BaseUsingDecl.cpp
+++ b/bindings/Python/Generated/AST/BaseUsingDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -282,18 +281,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::BaseUsingDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BaseUsingDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BaseUsingDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -319,7 +356,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -342,52 +379,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BaseUsingDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BaseUsingDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BaseUsingDecl::from_base"),
-  },
   {
     "nth_shadow",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/BinaryConditionalOperator.cpp b/bindings/Python/Generated/AST/BinaryConditionalOperator.cpp
index 65810b2e6..bd11041c6 100644
--- a/bindings/Python/Generated/AST/BinaryConditionalOperator.cpp
+++ b/bindings/Python/Generated/AST/BinaryConditionalOperator.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BinaryConditionalOperator::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BinaryConditionalOperator::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BinaryConditionalOperator::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BinaryConditionalOperator::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/BinaryOperator.cpp b/bindings/Python/Generated/AST/BinaryOperator.cpp
index dea1f2995..825abff45 100644
--- a/bindings/Python/Generated/AST/BinaryOperator.cpp
+++ b/bindings/Python/Generated/AST/BinaryOperator.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -421,67 +420,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BinaryOperator::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BinaryOperator::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -545,6 +483,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BinaryOperator::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BinaryOperator::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/BindingDecl.cpp b/bindings/Python/Generated/AST/BindingDecl.cpp
index bb9e4ee3e..aa983c30d 100644
--- a/bindings/Python/Generated/AST/BindingDecl.cpp
+++ b/bindings/Python/Generated/AST/BindingDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BindingDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BindingDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BindingDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BindingDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/BitIntType.cpp b/bindings/Python/Generated/AST/BitIntType.cpp
index 1e3e73bae..1fe568f5d 100644
--- a/bindings/Python/Generated/AST/BitIntType.cpp
+++ b/bindings/Python/Generated/AST/BitIntType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BlockDecl.cpp b/bindings/Python/Generated/AST/BlockDecl.cpp
index 4c39f6502..ecfb6f11e 100644
--- a/bindings/Python/Generated/AST/BlockDecl.cpp
+++ b/bindings/Python/Generated/AST/BlockDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -427,67 +426,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BlockDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BlockDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -551,6 +489,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BlockDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BlockDecl::from"),
+  },
   {
     "nth_parameter",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/BlockExpr.cpp b/bindings/Python/Generated/AST/BlockExpr.cpp
index 8a641ffa4..9e1bd7ea6 100644
--- a/bindings/Python/Generated/AST/BlockExpr.cpp
+++ b/bindings/Python/Generated/AST/BlockExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BlockExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BlockExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BlockExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BlockExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/BlockPointerType.cpp b/bindings/Python/Generated/AST/BlockPointerType.cpp
index 456b7332b..0862ce132 100644
--- a/bindings/Python/Generated/AST/BlockPointerType.cpp
+++ b/bindings/Python/Generated/AST/BlockPointerType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BlocksAttr.cpp b/bindings/Python/Generated/AST/BlocksAttr.cpp
index fff9cb2b1..047a2da03 100644
--- a/bindings/Python/Generated/AST/BlocksAttr.cpp
+++ b/bindings/Python/Generated/AST/BlocksAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BreakStmt.cpp b/bindings/Python/Generated/AST/BreakStmt.cpp
index 6cc6bdb92..b3bb72b48 100644
--- a/bindings/Python/Generated/AST/BreakStmt.cpp
+++ b/bindings/Python/Generated/AST/BreakStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BreakStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BreakStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BreakStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BreakStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/BuiltinAliasAttr.cpp b/bindings/Python/Generated/AST/BuiltinAliasAttr.cpp
index 01518df7c..0d79b362a 100644
--- a/bindings/Python/Generated/AST/BuiltinAliasAttr.cpp
+++ b/bindings/Python/Generated/AST/BuiltinAliasAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BuiltinAttr.cpp b/bindings/Python/Generated/AST/BuiltinAttr.cpp
index 54859af29..d4a416294 100644
--- a/bindings/Python/Generated/AST/BuiltinAttr.cpp
+++ b/bindings/Python/Generated/AST/BuiltinAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/BuiltinBitCastExpr.cpp b/bindings/Python/Generated/AST/BuiltinBitCastExpr.cpp
index 1f9ffad7e..4e7aa48f5 100644
--- a/bindings/Python/Generated/AST/BuiltinBitCastExpr.cpp
+++ b/bindings/Python/Generated/AST/BuiltinBitCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BuiltinBitCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BuiltinBitCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BuiltinBitCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BuiltinBitCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/BuiltinTemplateDecl.cpp b/bindings/Python/Generated/AST/BuiltinTemplateDecl.cpp
index d6d313bf9..8ae6246f5 100644
--- a/bindings/Python/Generated/AST/BuiltinTemplateDecl.cpp
+++ b/bindings/Python/Generated/AST/BuiltinTemplateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BuiltinTemplateDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::BuiltinTemplateDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::BuiltinTemplateDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::BuiltinTemplateDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/BuiltinType.cpp b/bindings/Python/Generated/AST/BuiltinType.cpp
index 62f58da0c..90c8b2a38 100644
--- a/bindings/Python/Generated/AST/BuiltinType.cpp
+++ b/bindings/Python/Generated/AST/BuiltinType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -344,7 +343,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/C11NoReturnAttr.cpp b/bindings/Python/Generated/AST/C11NoReturnAttr.cpp
index 3be339489..e71e9a51f 100644
--- a/bindings/Python/Generated/AST/C11NoReturnAttr.cpp
+++ b/bindings/Python/Generated/AST/C11NoReturnAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CDeclAttr.cpp b/bindings/Python/Generated/AST/CDeclAttr.cpp
index 7a1f61157..3fbcf777d 100644
--- a/bindings/Python/Generated/AST/CDeclAttr.cpp
+++ b/bindings/Python/Generated/AST/CDeclAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CFAuditedTransferAttr.cpp b/bindings/Python/Generated/AST/CFAuditedTransferAttr.cpp
index 25172fa93..c50f37528 100644
--- a/bindings/Python/Generated/AST/CFAuditedTransferAttr.cpp
+++ b/bindings/Python/Generated/AST/CFAuditedTransferAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CFConsumedAttr.cpp b/bindings/Python/Generated/AST/CFConsumedAttr.cpp
index cd5684428..5b98f5446 100644
--- a/bindings/Python/Generated/AST/CFConsumedAttr.cpp
+++ b/bindings/Python/Generated/AST/CFConsumedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CFGuardAttr.cpp b/bindings/Python/Generated/AST/CFGuardAttr.cpp
index 59f18bedf..f1c023f64 100644
--- a/bindings/Python/Generated/AST/CFGuardAttr.cpp
+++ b/bindings/Python/Generated/AST/CFGuardAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CFICanonicalJumpTableAttr.cpp b/bindings/Python/Generated/AST/CFICanonicalJumpTableAttr.cpp
index 63171ba1e..781bb5f91 100644
--- a/bindings/Python/Generated/AST/CFICanonicalJumpTableAttr.cpp
+++ b/bindings/Python/Generated/AST/CFICanonicalJumpTableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CFReturnsNotRetainedAttr.cpp b/bindings/Python/Generated/AST/CFReturnsNotRetainedAttr.cpp
index b52df9a1c..b3f6bd056 100644
--- a/bindings/Python/Generated/AST/CFReturnsNotRetainedAttr.cpp
+++ b/bindings/Python/Generated/AST/CFReturnsNotRetainedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CFReturnsRetainedAttr.cpp b/bindings/Python/Generated/AST/CFReturnsRetainedAttr.cpp
index 542cad2ee..b1ba2982a 100644
--- a/bindings/Python/Generated/AST/CFReturnsRetainedAttr.cpp
+++ b/bindings/Python/Generated/AST/CFReturnsRetainedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CFUnknownTransferAttr.cpp b/bindings/Python/Generated/AST/CFUnknownTransferAttr.cpp
index 3e9ad19f7..87ccb15ef 100644
--- a/bindings/Python/Generated/AST/CFUnknownTransferAttr.cpp
+++ b/bindings/Python/Generated/AST/CFUnknownTransferAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CPUDispatchAttr.cpp b/bindings/Python/Generated/AST/CPUDispatchAttr.cpp
index 7b354d56e..32e3523a0 100644
--- a/bindings/Python/Generated/AST/CPUDispatchAttr.cpp
+++ b/bindings/Python/Generated/AST/CPUDispatchAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CPUSpecificAttr.cpp b/bindings/Python/Generated/AST/CPUSpecificAttr.cpp
index 415c1ed44..4309cc733 100644
--- a/bindings/Python/Generated/AST/CPUSpecificAttr.cpp
+++ b/bindings/Python/Generated/AST/CPUSpecificAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CStyleCastExpr.cpp b/bindings/Python/Generated/AST/CStyleCastExpr.cpp
index 338781fd2..d8646aed4 100644
--- a/bindings/Python/Generated/AST/CStyleCastExpr.cpp
+++ b/bindings/Python/Generated/AST/CStyleCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CStyleCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CStyleCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CStyleCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CStyleCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CUDAConstantAttr.cpp b/bindings/Python/Generated/AST/CUDAConstantAttr.cpp
index 68b671f5c..1ed5d0a9a 100644
--- a/bindings/Python/Generated/AST/CUDAConstantAttr.cpp
+++ b/bindings/Python/Generated/AST/CUDAConstantAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CUDADeviceAttr.cpp b/bindings/Python/Generated/AST/CUDADeviceAttr.cpp
index 4257656e7..ccab33d37 100644
--- a/bindings/Python/Generated/AST/CUDADeviceAttr.cpp
+++ b/bindings/Python/Generated/AST/CUDADeviceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CUDADeviceBuiltinSurfaceTypeAttr.cpp b/bindings/Python/Generated/AST/CUDADeviceBuiltinSurfaceTypeAttr.cpp
index a06b29389..3fb916713 100644
--- a/bindings/Python/Generated/AST/CUDADeviceBuiltinSurfaceTypeAttr.cpp
+++ b/bindings/Python/Generated/AST/CUDADeviceBuiltinSurfaceTypeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CUDADeviceBuiltinTextureTypeAttr.cpp b/bindings/Python/Generated/AST/CUDADeviceBuiltinTextureTypeAttr.cpp
index dd81150f2..6bb171171 100644
--- a/bindings/Python/Generated/AST/CUDADeviceBuiltinTextureTypeAttr.cpp
+++ b/bindings/Python/Generated/AST/CUDADeviceBuiltinTextureTypeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CUDAGlobalAttr.cpp b/bindings/Python/Generated/AST/CUDAGlobalAttr.cpp
index 5df2b8e88..b5618b785 100644
--- a/bindings/Python/Generated/AST/CUDAGlobalAttr.cpp
+++ b/bindings/Python/Generated/AST/CUDAGlobalAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CUDAHostAttr.cpp b/bindings/Python/Generated/AST/CUDAHostAttr.cpp
index f9ad10858..cac8e30a8 100644
--- a/bindings/Python/Generated/AST/CUDAHostAttr.cpp
+++ b/bindings/Python/Generated/AST/CUDAHostAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CUDAInvalidTargetAttr.cpp b/bindings/Python/Generated/AST/CUDAInvalidTargetAttr.cpp
index 52d628ed9..39a130f00 100644
--- a/bindings/Python/Generated/AST/CUDAInvalidTargetAttr.cpp
+++ b/bindings/Python/Generated/AST/CUDAInvalidTargetAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CUDAKernelCallExpr.cpp b/bindings/Python/Generated/AST/CUDAKernelCallExpr.cpp
index 90042887f..1f661143e 100644
--- a/bindings/Python/Generated/AST/CUDAKernelCallExpr.cpp
+++ b/bindings/Python/Generated/AST/CUDAKernelCallExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CUDAKernelCallExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CUDAKernelCallExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CUDAKernelCallExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CUDAKernelCallExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CUDALaunchBoundsAttr.cpp b/bindings/Python/Generated/AST/CUDALaunchBoundsAttr.cpp
index 756739898..6a4f3cccc 100644
--- a/bindings/Python/Generated/AST/CUDALaunchBoundsAttr.cpp
+++ b/bindings/Python/Generated/AST/CUDALaunchBoundsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CUDASharedAttr.cpp b/bindings/Python/Generated/AST/CUDASharedAttr.cpp
index 5141922fe..bf89f2842 100644
--- a/bindings/Python/Generated/AST/CUDASharedAttr.cpp
+++ b/bindings/Python/Generated/AST/CUDASharedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CXX11NoReturnAttr.cpp b/bindings/Python/Generated/AST/CXX11NoReturnAttr.cpp
index a2021b711..c96f38e6c 100644
--- a/bindings/Python/Generated/AST/CXX11NoReturnAttr.cpp
+++ b/bindings/Python/Generated/AST/CXX11NoReturnAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CXXAddrspaceCastExpr.cpp b/bindings/Python/Generated/AST/CXXAddrspaceCastExpr.cpp
index 7601a1477..0f1e8dcbd 100644
--- a/bindings/Python/Generated/AST/CXXAddrspaceCastExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXAddrspaceCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXAddrspaceCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXAddrspaceCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXAddrspaceCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXAddrspaceCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXBaseSpecifier.cpp b/bindings/Python/Generated/AST/CXXBaseSpecifier.cpp
index f454b9c41..f9f546e33 100644
--- a/bindings/Python/Generated/AST/CXXBaseSpecifier.cpp
+++ b/bindings/Python/Generated/AST/CXXBaseSpecifier.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -387,7 +386,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CXXBindTemporaryExpr.cpp b/bindings/Python/Generated/AST/CXXBindTemporaryExpr.cpp
index 5a7b2d8ca..0ce445863 100644
--- a/bindings/Python/Generated/AST/CXXBindTemporaryExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXBindTemporaryExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXBindTemporaryExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXBindTemporaryExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXBindTemporaryExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXBindTemporaryExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXBoolLiteralExpr.cpp b/bindings/Python/Generated/AST/CXXBoolLiteralExpr.cpp
index c12733f72..1c8c424e7 100644
--- a/bindings/Python/Generated/AST/CXXBoolLiteralExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXBoolLiteralExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXBoolLiteralExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXBoolLiteralExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXBoolLiteralExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXBoolLiteralExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXCatchStmt.cpp b/bindings/Python/Generated/AST/CXXCatchStmt.cpp
index b339a6fc5..493ee108b 100644
--- a/bindings/Python/Generated/AST/CXXCatchStmt.cpp
+++ b/bindings/Python/Generated/AST/CXXCatchStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXCatchStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXCatchStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXCatchStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXCatchStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXConstCastExpr.cpp b/bindings/Python/Generated/AST/CXXConstCastExpr.cpp
index c9b74c765..1131ac22e 100644
--- a/bindings/Python/Generated/AST/CXXConstCastExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXConstCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXConstCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXConstCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXConstCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXConstCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXConstructExpr.cpp b/bindings/Python/Generated/AST/CXXConstructExpr.cpp
index 674e4070f..44a1ddece 100644
--- a/bindings/Python/Generated/AST/CXXConstructExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXConstructExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -351,67 +350,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXConstructExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXConstructExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -475,6 +413,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXConstructExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXConstructExpr::from"),
+  },
   {
     "nth_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CXXConstructorDecl.cpp b/bindings/Python/Generated/AST/CXXConstructorDecl.cpp
index f48099323..ec5fd5e81 100644
--- a/bindings/Python/Generated/AST/CXXConstructorDecl.cpp
+++ b/bindings/Python/Generated/AST/CXXConstructorDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -337,67 +336,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXConstructorDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXConstructorDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -461,6 +399,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXConstructorDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXConstructorDecl::from"),
+  },
   {
     "nth_initializer",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CXXConversionDecl.cpp b/bindings/Python/Generated/AST/CXXConversionDecl.cpp
index bf88404f0..d1c24ff32 100644
--- a/bindings/Python/Generated/AST/CXXConversionDecl.cpp
+++ b/bindings/Python/Generated/AST/CXXConversionDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXConversionDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXConversionDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXConversionDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXConversionDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXCtorInitializer.cpp b/bindings/Python/Generated/AST/CXXCtorInitializer.cpp
index 1343271a1..8d57214c7 100644
--- a/bindings/Python/Generated/AST/CXXCtorInitializer.cpp
+++ b/bindings/Python/Generated/AST/CXXCtorInitializer.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -437,7 +436,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CXXDeductionGuideDecl.cpp b/bindings/Python/Generated/AST/CXXDeductionGuideDecl.cpp
index ee15593d7..3e2dda7f8 100644
--- a/bindings/Python/Generated/AST/CXXDeductionGuideDecl.cpp
+++ b/bindings/Python/Generated/AST/CXXDeductionGuideDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDeductionGuideDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXDeductionGuideDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDeductionGuideDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXDeductionGuideDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXDefaultArgExpr.cpp b/bindings/Python/Generated/AST/CXXDefaultArgExpr.cpp
index 7f8cfab39..e3e135cdb 100644
--- a/bindings/Python/Generated/AST/CXXDefaultArgExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXDefaultArgExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDefaultArgExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXDefaultArgExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDefaultArgExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXDefaultArgExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXDefaultInitExpr.cpp b/bindings/Python/Generated/AST/CXXDefaultInitExpr.cpp
index 2f79480aa..bdd1bbcb2 100644
--- a/bindings/Python/Generated/AST/CXXDefaultInitExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXDefaultInitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDefaultInitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXDefaultInitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDefaultInitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXDefaultInitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXDeleteExpr.cpp b/bindings/Python/Generated/AST/CXXDeleteExpr.cpp
index 9e3ddc4b8..d0810a9dc 100644
--- a/bindings/Python/Generated/AST/CXXDeleteExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXDeleteExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDeleteExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXDeleteExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDeleteExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXDeleteExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXDependentScopeMemberExpr.cpp b/bindings/Python/Generated/AST/CXXDependentScopeMemberExpr.cpp
index c429480a3..f99b8f9d2 100644
--- a/bindings/Python/Generated/AST/CXXDependentScopeMemberExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXDependentScopeMemberExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -347,67 +346,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDependentScopeMemberExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXDependentScopeMemberExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -471,6 +409,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDependentScopeMemberExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXDependentScopeMemberExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXDestructorDecl.cpp b/bindings/Python/Generated/AST/CXXDestructorDecl.cpp
index 8ba640065..52694e573 100644
--- a/bindings/Python/Generated/AST/CXXDestructorDecl.cpp
+++ b/bindings/Python/Generated/AST/CXXDestructorDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDestructorDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXDestructorDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDestructorDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXDestructorDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXDynamicCastExpr.cpp b/bindings/Python/Generated/AST/CXXDynamicCastExpr.cpp
index fd38abda1..a1447edab 100644
--- a/bindings/Python/Generated/AST/CXXDynamicCastExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXDynamicCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDynamicCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXDynamicCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXDynamicCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXDynamicCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXFoldExpr.cpp b/bindings/Python/Generated/AST/CXXFoldExpr.cpp
index 9d2d100a2..51a485755 100644
--- a/bindings/Python/Generated/AST/CXXFoldExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXFoldExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -337,67 +336,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXFoldExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXFoldExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -461,6 +399,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXFoldExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXFoldExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXForRangeStmt.cpp b/bindings/Python/Generated/AST/CXXForRangeStmt.cpp
index 6563c339e..02eb856fd 100644
--- a/bindings/Python/Generated/AST/CXXForRangeStmt.cpp
+++ b/bindings/Python/Generated/AST/CXXForRangeStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -367,67 +366,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXForRangeStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXForRangeStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -491,6 +429,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXForRangeStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXForRangeStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXFunctionalCastExpr.cpp b/bindings/Python/Generated/AST/CXXFunctionalCastExpr.cpp
index 409bfd088..9ba31c2fe 100644
--- a/bindings/Python/Generated/AST/CXXFunctionalCastExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXFunctionalCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXFunctionalCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXFunctionalCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXFunctionalCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXFunctionalCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXInheritedCtorInitExpr.cpp b/bindings/Python/Generated/AST/CXXInheritedCtorInitExpr.cpp
index becdf2400..522d3e70a 100644
--- a/bindings/Python/Generated/AST/CXXInheritedCtorInitExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXInheritedCtorInitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXInheritedCtorInitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXInheritedCtorInitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXInheritedCtorInitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXInheritedCtorInitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXMemberCallExpr.cpp b/bindings/Python/Generated/AST/CXXMemberCallExpr.cpp
index 835c88922..0be5b9359 100644
--- a/bindings/Python/Generated/AST/CXXMemberCallExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXMemberCallExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXMemberCallExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXMemberCallExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXMemberCallExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXMemberCallExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXMethodDecl.cpp b/bindings/Python/Generated/AST/CXXMethodDecl.cpp
index 493a72303..a6227e4c5 100644
--- a/bindings/Python/Generated/AST/CXXMethodDecl.cpp
+++ b/bindings/Python/Generated/AST/CXXMethodDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -459,67 +458,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXMethodDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXMethodDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -583,6 +521,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXMethodDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXMethodDecl::from"),
+  },
   {
     "nth_overridden_method",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CXXNamedCastExpr.cpp b/bindings/Python/Generated/AST/CXXNamedCastExpr.cpp
index 60680118b..d9349e3e9 100644
--- a/bindings/Python/Generated/AST/CXXNamedCastExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXNamedCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,18 +283,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::CXXNamedCastExpr::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXNamedCastExpr::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXNamedCastExpr::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -321,7 +358,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -344,52 +381,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXNamedCastExpr::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXNamedCastExpr::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXNamedCastExpr::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXNewExpr.cpp b/bindings/Python/Generated/AST/CXXNewExpr.cpp
index 22771f030..5985c24a3 100644
--- a/bindings/Python/Generated/AST/CXXNewExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXNewExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -397,67 +396,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXNewExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXNewExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -521,6 +459,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXNewExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXNewExpr::from"),
+  },
   {
     "nth_placement_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CXXNoexceptExpr.cpp b/bindings/Python/Generated/AST/CXXNoexceptExpr.cpp
index b6df93a69..a0050b0a6 100644
--- a/bindings/Python/Generated/AST/CXXNoexceptExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXNoexceptExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXNoexceptExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXNoexceptExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXNoexceptExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXNoexceptExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXNullPtrLiteralExpr.cpp b/bindings/Python/Generated/AST/CXXNullPtrLiteralExpr.cpp
index b85f9cb8f..c0b810539 100644
--- a/bindings/Python/Generated/AST/CXXNullPtrLiteralExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXNullPtrLiteralExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXNullPtrLiteralExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXNullPtrLiteralExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXNullPtrLiteralExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXNullPtrLiteralExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXOperatorCallExpr.cpp b/bindings/Python/Generated/AST/CXXOperatorCallExpr.cpp
index 194715a13..0e6d48ab5 100644
--- a/bindings/Python/Generated/AST/CXXOperatorCallExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXOperatorCallExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXOperatorCallExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXOperatorCallExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXOperatorCallExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXOperatorCallExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXParenListInitExpr.cpp b/bindings/Python/Generated/AST/CXXParenListInitExpr.cpp
index 7e3e86dab..8144d8e4d 100644
--- a/bindings/Python/Generated/AST/CXXParenListInitExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXParenListInitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXParenListInitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXParenListInitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXParenListInitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXParenListInitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXPseudoDestructorExpr.cpp b/bindings/Python/Generated/AST/CXXPseudoDestructorExpr.cpp
index b7f1ba605..82761cfa9 100644
--- a/bindings/Python/Generated/AST/CXXPseudoDestructorExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXPseudoDestructorExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXPseudoDestructorExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXPseudoDestructorExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXPseudoDestructorExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXPseudoDestructorExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXRecordDecl.cpp b/bindings/Python/Generated/AST/CXXRecordDecl.cpp
index 4c69fcdd7..c7069ca0b 100644
--- a/bindings/Python/Generated/AST/CXXRecordDecl.cpp
+++ b/bindings/Python/Generated/AST/CXXRecordDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -1515,67 +1514,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXRecordDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXRecordDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -1639,6 +1577,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXRecordDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXRecordDecl::from"),
+  },
   {
     "nth_constructor",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CXXReinterpretCastExpr.cpp b/bindings/Python/Generated/AST/CXXReinterpretCastExpr.cpp
index f76fb2be1..94542498e 100644
--- a/bindings/Python/Generated/AST/CXXReinterpretCastExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXReinterpretCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXReinterpretCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXReinterpretCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXReinterpretCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXReinterpretCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXRewrittenBinaryOperator.cpp b/bindings/Python/Generated/AST/CXXRewrittenBinaryOperator.cpp
index fe0b4bfe2..3930ac90f 100644
--- a/bindings/Python/Generated/AST/CXXRewrittenBinaryOperator.cpp
+++ b/bindings/Python/Generated/AST/CXXRewrittenBinaryOperator.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -327,67 +326,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXRewrittenBinaryOperator::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXRewrittenBinaryOperator::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -451,6 +389,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXRewrittenBinaryOperator::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXRewrittenBinaryOperator::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXScalarValueInitExpr.cpp b/bindings/Python/Generated/AST/CXXScalarValueInitExpr.cpp
index c4374d058..a869372b6 100644
--- a/bindings/Python/Generated/AST/CXXScalarValueInitExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXScalarValueInitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXScalarValueInitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXScalarValueInitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXScalarValueInitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXScalarValueInitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXStaticCastExpr.cpp b/bindings/Python/Generated/AST/CXXStaticCastExpr.cpp
index ad4386bcf..6ca813b09 100644
--- a/bindings/Python/Generated/AST/CXXStaticCastExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXStaticCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXStaticCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXStaticCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXStaticCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXStaticCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXStdInitializerListExpr.cpp b/bindings/Python/Generated/AST/CXXStdInitializerListExpr.cpp
index 99c41d450..5e7d22507 100644
--- a/bindings/Python/Generated/AST/CXXStdInitializerListExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXStdInitializerListExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXStdInitializerListExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXStdInitializerListExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXStdInitializerListExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXStdInitializerListExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXTemporaryObjectExpr.cpp b/bindings/Python/Generated/AST/CXXTemporaryObjectExpr.cpp
index 2a5451896..a3e3c7217 100644
--- a/bindings/Python/Generated/AST/CXXTemporaryObjectExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXTemporaryObjectExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXTemporaryObjectExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXTemporaryObjectExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXTemporaryObjectExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXTemporaryObjectExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXThisExpr.cpp b/bindings/Python/Generated/AST/CXXThisExpr.cpp
index 1c1f0c759..79b66c4fc 100644
--- a/bindings/Python/Generated/AST/CXXThisExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXThisExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXThisExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXThisExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXThisExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXThisExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXThrowExpr.cpp b/bindings/Python/Generated/AST/CXXThrowExpr.cpp
index 19f2f2552..1efdc1750 100644
--- a/bindings/Python/Generated/AST/CXXThrowExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXThrowExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXThrowExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXThrowExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXThrowExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXThrowExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXTryStmt.cpp b/bindings/Python/Generated/AST/CXXTryStmt.cpp
index 02a0e2706..fb95e9d95 100644
--- a/bindings/Python/Generated/AST/CXXTryStmt.cpp
+++ b/bindings/Python/Generated/AST/CXXTryStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXTryStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXTryStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXTryStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXTryStmt::from"),
+  },
   {
     "nth_handler",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CXXTypeidExpr.cpp b/bindings/Python/Generated/AST/CXXTypeidExpr.cpp
index 3d03d3536..4403edea4 100644
--- a/bindings/Python/Generated/AST/CXXTypeidExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXTypeidExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXTypeidExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXTypeidExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXTypeidExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXTypeidExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CXXUnresolvedConstructExpr.cpp b/bindings/Python/Generated/AST/CXXUnresolvedConstructExpr.cpp
index 75147dde6..74ad96adf 100644
--- a/bindings/Python/Generated/AST/CXXUnresolvedConstructExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXUnresolvedConstructExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXUnresolvedConstructExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXUnresolvedConstructExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXUnresolvedConstructExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXUnresolvedConstructExpr::from"),
+  },
   {
     "nth_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CXXUuidofExpr.cpp b/bindings/Python/Generated/AST/CXXUuidofExpr.cpp
index 2db2b553c..75b08560e 100644
--- a/bindings/Python/Generated/AST/CXXUuidofExpr.cpp
+++ b/bindings/Python/Generated/AST/CXXUuidofExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXUuidofExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CXXUuidofExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CXXUuidofExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CXXUuidofExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CallExpr.cpp b/bindings/Python/Generated/AST/CallExpr.cpp
index 3ae330073..845c1c932 100644
--- a/bindings/Python/Generated/AST/CallExpr.cpp
+++ b/bindings/Python/Generated/AST/CallExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -413,67 +412,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CallExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CallExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -537,6 +475,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CallExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CallExpr::from"),
+  },
   {
     "nth_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CallableWhenAttr.cpp b/bindings/Python/Generated/AST/CallableWhenAttr.cpp
index 5a7412795..ad37d24bb 100644
--- a/bindings/Python/Generated/AST/CallableWhenAttr.cpp
+++ b/bindings/Python/Generated/AST/CallableWhenAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CallbackAttr.cpp b/bindings/Python/Generated/AST/CallbackAttr.cpp
index 34972ec85..87ece8960 100644
--- a/bindings/Python/Generated/AST/CallbackAttr.cpp
+++ b/bindings/Python/Generated/AST/CallbackAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CalledOnceAttr.cpp b/bindings/Python/Generated/AST/CalledOnceAttr.cpp
index 496791e5d..1da3e352d 100644
--- a/bindings/Python/Generated/AST/CalledOnceAttr.cpp
+++ b/bindings/Python/Generated/AST/CalledOnceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CapabilityAttr.cpp b/bindings/Python/Generated/AST/CapabilityAttr.cpp
index f0f567372..abbdc4d40 100644
--- a/bindings/Python/Generated/AST/CapabilityAttr.cpp
+++ b/bindings/Python/Generated/AST/CapabilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -320,7 +319,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CapturedDecl.cpp b/bindings/Python/Generated/AST/CapturedDecl.cpp
index 8c138eb52..07530c09e 100644
--- a/bindings/Python/Generated/AST/CapturedDecl.cpp
+++ b/bindings/Python/Generated/AST/CapturedDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -317,67 +316,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CapturedDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CapturedDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -441,6 +379,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CapturedDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CapturedDecl::from"),
+  },
   {
     "nth_parameter",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CapturedRecordAttr.cpp b/bindings/Python/Generated/AST/CapturedRecordAttr.cpp
index 7c99cda7c..37e180a08 100644
--- a/bindings/Python/Generated/AST/CapturedRecordAttr.cpp
+++ b/bindings/Python/Generated/AST/CapturedRecordAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CapturedStmt.cpp b/bindings/Python/Generated/AST/CapturedStmt.cpp
index 258b5908f..aecdc0364 100644
--- a/bindings/Python/Generated/AST/CapturedStmt.cpp
+++ b/bindings/Python/Generated/AST/CapturedStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CapturedStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CapturedStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CapturedStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CapturedStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CarriesDependencyAttr.cpp b/bindings/Python/Generated/AST/CarriesDependencyAttr.cpp
index 0537d5cd6..e911b6036 100644
--- a/bindings/Python/Generated/AST/CarriesDependencyAttr.cpp
+++ b/bindings/Python/Generated/AST/CarriesDependencyAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CaseStmt.cpp b/bindings/Python/Generated/AST/CaseStmt.cpp
index 526f42afd..4e2ac4d9d 100644
--- a/bindings/Python/Generated/AST/CaseStmt.cpp
+++ b/bindings/Python/Generated/AST/CaseStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CaseStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CaseStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CaseStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CaseStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CastExpr.cpp b/bindings/Python/Generated/AST/CastExpr.cpp
index 49fae2536..1fa47b741 100644
--- a/bindings/Python/Generated/AST/CastExpr.cpp
+++ b/bindings/Python/Generated/AST/CastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -344,18 +343,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::CastExpr::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CastExpr::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CastExpr::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -381,7 +418,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -404,52 +441,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CastExpr::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CastExpr::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CastExpr::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CharacterLiteral.cpp b/bindings/Python/Generated/AST/CharacterLiteral.cpp
index 86ae8f7bc..117d444e1 100644
--- a/bindings/Python/Generated/AST/CharacterLiteral.cpp
+++ b/bindings/Python/Generated/AST/CharacterLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CharacterLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CharacterLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CharacterLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CharacterLiteral::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ChooseExpr.cpp b/bindings/Python/Generated/AST/ChooseExpr.cpp
index e08cffcc3..fda00c4fd 100644
--- a/bindings/Python/Generated/AST/ChooseExpr.cpp
+++ b/bindings/Python/Generated/AST/ChooseExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ChooseExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ChooseExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ChooseExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ChooseExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ClassTemplateDecl.cpp b/bindings/Python/Generated/AST/ClassTemplateDecl.cpp
index 615f6f8db..e4eb15d26 100644
--- a/bindings/Python/Generated/AST/ClassTemplateDecl.cpp
+++ b/bindings/Python/Generated/AST/ClassTemplateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ClassTemplateDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ClassTemplateDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ClassTemplateDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ClassTemplateDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ClassTemplatePartialSpecializationDecl.cpp b/bindings/Python/Generated/AST/ClassTemplatePartialSpecializationDecl.cpp
index ecae39386..f6ecf0c77 100644
--- a/bindings/Python/Generated/AST/ClassTemplatePartialSpecializationDecl.cpp
+++ b/bindings/Python/Generated/AST/ClassTemplatePartialSpecializationDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ClassTemplatePartialSpecializationDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ClassTemplatePartialSpecializationDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ClassTemplatePartialSpecializationDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ClassTemplatePartialSpecializationDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ClassTemplateSpecializationDecl.cpp b/bindings/Python/Generated/AST/ClassTemplateSpecializationDecl.cpp
index ec597d191..d41b85e00 100644
--- a/bindings/Python/Generated/AST/ClassTemplateSpecializationDecl.cpp
+++ b/bindings/Python/Generated/AST/ClassTemplateSpecializationDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -351,67 +350,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ClassTemplateSpecializationDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ClassTemplateSpecializationDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -475,6 +413,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ClassTemplateSpecializationDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ClassTemplateSpecializationDecl::from"),
+  },
   {
     "nth_template_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CleanupAttr.cpp b/bindings/Python/Generated/AST/CleanupAttr.cpp
index 9adeac07d..50a0e4ee6 100644
--- a/bindings/Python/Generated/AST/CleanupAttr.cpp
+++ b/bindings/Python/Generated/AST/CleanupAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CmseNSCallAttr.cpp b/bindings/Python/Generated/AST/CmseNSCallAttr.cpp
index 9ce78857e..ca52aa45f 100644
--- a/bindings/Python/Generated/AST/CmseNSCallAttr.cpp
+++ b/bindings/Python/Generated/AST/CmseNSCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CmseNSEntryAttr.cpp b/bindings/Python/Generated/AST/CmseNSEntryAttr.cpp
index 897987810..a730e1b15 100644
--- a/bindings/Python/Generated/AST/CmseNSEntryAttr.cpp
+++ b/bindings/Python/Generated/AST/CmseNSEntryAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CoawaitExpr.cpp b/bindings/Python/Generated/AST/CoawaitExpr.cpp
index 87f7dbe10..5e02389c5 100644
--- a/bindings/Python/Generated/AST/CoawaitExpr.cpp
+++ b/bindings/Python/Generated/AST/CoawaitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CoawaitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CoawaitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CoawaitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CoawaitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CodeAlignAttr.cpp b/bindings/Python/Generated/AST/CodeAlignAttr.cpp
index bc837bce4..79f12a84e 100644
--- a/bindings/Python/Generated/AST/CodeAlignAttr.cpp
+++ b/bindings/Python/Generated/AST/CodeAlignAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CodeModelAttr.cpp b/bindings/Python/Generated/AST/CodeModelAttr.cpp
index 446605fe3..e57c324f2 100644
--- a/bindings/Python/Generated/AST/CodeModelAttr.cpp
+++ b/bindings/Python/Generated/AST/CodeModelAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CodeSegAttr.cpp b/bindings/Python/Generated/AST/CodeSegAttr.cpp
index 98884e414..e5be4ac10 100644
--- a/bindings/Python/Generated/AST/CodeSegAttr.cpp
+++ b/bindings/Python/Generated/AST/CodeSegAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ColdAttr.cpp b/bindings/Python/Generated/AST/ColdAttr.cpp
index 64f38d029..182415ac4 100644
--- a/bindings/Python/Generated/AST/ColdAttr.cpp
+++ b/bindings/Python/Generated/AST/ColdAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CommonAttr.cpp b/bindings/Python/Generated/AST/CommonAttr.cpp
index 440f7a24c..b80171333 100644
--- a/bindings/Python/Generated/AST/CommonAttr.cpp
+++ b/bindings/Python/Generated/AST/CommonAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ComplexType.cpp b/bindings/Python/Generated/AST/ComplexType.cpp
index 15364c113..9f9ff75a5 100644
--- a/bindings/Python/Generated/AST/ComplexType.cpp
+++ b/bindings/Python/Generated/AST/ComplexType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CompoundAssignOperator.cpp b/bindings/Python/Generated/AST/CompoundAssignOperator.cpp
index 081cdd6af..187950d3e 100644
--- a/bindings/Python/Generated/AST/CompoundAssignOperator.cpp
+++ b/bindings/Python/Generated/AST/CompoundAssignOperator.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CompoundAssignOperator::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CompoundAssignOperator::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CompoundAssignOperator::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CompoundAssignOperator::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CompoundLiteralExpr.cpp b/bindings/Python/Generated/AST/CompoundLiteralExpr.cpp
index 6433a4eef..98789451d 100644
--- a/bindings/Python/Generated/AST/CompoundLiteralExpr.cpp
+++ b/bindings/Python/Generated/AST/CompoundLiteralExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CompoundLiteralExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CompoundLiteralExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CompoundLiteralExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CompoundLiteralExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CompoundStmt.cpp b/bindings/Python/Generated/AST/CompoundStmt.cpp
index de6cc7d57..d549f19a3 100644
--- a/bindings/Python/Generated/AST/CompoundStmt.cpp
+++ b/bindings/Python/Generated/AST/CompoundStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CompoundStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CompoundStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CompoundStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CompoundStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ConceptDecl.cpp b/bindings/Python/Generated/AST/ConceptDecl.cpp
index 2126572e1..3c4075cfd 100644
--- a/bindings/Python/Generated/AST/ConceptDecl.cpp
+++ b/bindings/Python/Generated/AST/ConceptDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConceptDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ConceptDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConceptDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ConceptDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ConceptSpecializationExpr.cpp b/bindings/Python/Generated/AST/ConceptSpecializationExpr.cpp
index ee1f84cc0..b0f8ea03a 100644
--- a/bindings/Python/Generated/AST/ConceptSpecializationExpr.cpp
+++ b/bindings/Python/Generated/AST/ConceptSpecializationExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConceptSpecializationExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ConceptSpecializationExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConceptSpecializationExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ConceptSpecializationExpr::from"),
+  },
   {
     "nth_template_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ConditionalOperator.cpp b/bindings/Python/Generated/AST/ConditionalOperator.cpp
index 574a73875..f40b5b743 100644
--- a/bindings/Python/Generated/AST/ConditionalOperator.cpp
+++ b/bindings/Python/Generated/AST/ConditionalOperator.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConditionalOperator::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ConditionalOperator::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConditionalOperator::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ConditionalOperator::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ConstAttr.cpp b/bindings/Python/Generated/AST/ConstAttr.cpp
index a87bd522e..0a758bef5 100644
--- a/bindings/Python/Generated/AST/ConstAttr.cpp
+++ b/bindings/Python/Generated/AST/ConstAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ConstInitAttr.cpp b/bindings/Python/Generated/AST/ConstInitAttr.cpp
index 454af0717..dd3b011e0 100644
--- a/bindings/Python/Generated/AST/ConstInitAttr.cpp
+++ b/bindings/Python/Generated/AST/ConstInitAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ConstantArrayType.cpp b/bindings/Python/Generated/AST/ConstantArrayType.cpp
index 1c7f93e28..f7f9bb222 100644
--- a/bindings/Python/Generated/AST/ConstantArrayType.cpp
+++ b/bindings/Python/Generated/AST/ConstantArrayType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ConstantExpr.cpp b/bindings/Python/Generated/AST/ConstantExpr.cpp
index 19884514b..a85f7e1af 100644
--- a/bindings/Python/Generated/AST/ConstantExpr.cpp
+++ b/bindings/Python/Generated/AST/ConstantExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConstantExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ConstantExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConstantExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ConstantExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ConstantMatrixType.cpp b/bindings/Python/Generated/AST/ConstantMatrixType.cpp
index 96f716f18..5eda08b3b 100644
--- a/bindings/Python/Generated/AST/ConstantMatrixType.cpp
+++ b/bindings/Python/Generated/AST/ConstantMatrixType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -274,7 +273,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ConstructorAttr.cpp b/bindings/Python/Generated/AST/ConstructorAttr.cpp
index 125559b1b..e34051a0f 100644
--- a/bindings/Python/Generated/AST/ConstructorAttr.cpp
+++ b/bindings/Python/Generated/AST/ConstructorAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ConstructorUsingShadowDecl.cpp b/bindings/Python/Generated/AST/ConstructorUsingShadowDecl.cpp
index a949e4afb..697641a67 100644
--- a/bindings/Python/Generated/AST/ConstructorUsingShadowDecl.cpp
+++ b/bindings/Python/Generated/AST/ConstructorUsingShadowDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConstructorUsingShadowDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ConstructorUsingShadowDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConstructorUsingShadowDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ConstructorUsingShadowDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ConsumableAttr.cpp b/bindings/Python/Generated/AST/ConsumableAttr.cpp
index 383a676c7..68d9f727a 100644
--- a/bindings/Python/Generated/AST/ConsumableAttr.cpp
+++ b/bindings/Python/Generated/AST/ConsumableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ConsumableAutoCastAttr.cpp b/bindings/Python/Generated/AST/ConsumableAutoCastAttr.cpp
index 60f768385..a2f278ece 100644
--- a/bindings/Python/Generated/AST/ConsumableAutoCastAttr.cpp
+++ b/bindings/Python/Generated/AST/ConsumableAutoCastAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ConsumableSetOnReadAttr.cpp b/bindings/Python/Generated/AST/ConsumableSetOnReadAttr.cpp
index fbb1636f0..efeacb335 100644
--- a/bindings/Python/Generated/AST/ConsumableSetOnReadAttr.cpp
+++ b/bindings/Python/Generated/AST/ConsumableSetOnReadAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ContinueStmt.cpp b/bindings/Python/Generated/AST/ContinueStmt.cpp
index 829397b6c..f5a4f1567 100644
--- a/bindings/Python/Generated/AST/ContinueStmt.cpp
+++ b/bindings/Python/Generated/AST/ContinueStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ContinueStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ContinueStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ContinueStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ContinueStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ConvergentAttr.cpp b/bindings/Python/Generated/AST/ConvergentAttr.cpp
index 10a1d89a1..9a31a9df8 100644
--- a/bindings/Python/Generated/AST/ConvergentAttr.cpp
+++ b/bindings/Python/Generated/AST/ConvergentAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ConvertVectorExpr.cpp b/bindings/Python/Generated/AST/ConvertVectorExpr.cpp
index 643c65415..1a30a8faa 100644
--- a/bindings/Python/Generated/AST/ConvertVectorExpr.cpp
+++ b/bindings/Python/Generated/AST/ConvertVectorExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConvertVectorExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ConvertVectorExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ConvertVectorExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ConvertVectorExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CoreturnStmt.cpp b/bindings/Python/Generated/AST/CoreturnStmt.cpp
index bbdec7873..4b7b560a6 100644
--- a/bindings/Python/Generated/AST/CoreturnStmt.cpp
+++ b/bindings/Python/Generated/AST/CoreturnStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CoreturnStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CoreturnStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CoreturnStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CoreturnStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CoroDisableLifetimeBoundAttr.cpp b/bindings/Python/Generated/AST/CoroDisableLifetimeBoundAttr.cpp
index e4f3932bb..582c5c26d 100644
--- a/bindings/Python/Generated/AST/CoroDisableLifetimeBoundAttr.cpp
+++ b/bindings/Python/Generated/AST/CoroDisableLifetimeBoundAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CoroLifetimeBoundAttr.cpp b/bindings/Python/Generated/AST/CoroLifetimeBoundAttr.cpp
index 6576785db..68bd39d6c 100644
--- a/bindings/Python/Generated/AST/CoroLifetimeBoundAttr.cpp
+++ b/bindings/Python/Generated/AST/CoroLifetimeBoundAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CoroOnlyDestroyWhenCompleteAttr.cpp b/bindings/Python/Generated/AST/CoroOnlyDestroyWhenCompleteAttr.cpp
index cc28318df..4db1ada35 100644
--- a/bindings/Python/Generated/AST/CoroOnlyDestroyWhenCompleteAttr.cpp
+++ b/bindings/Python/Generated/AST/CoroOnlyDestroyWhenCompleteAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CoroReturnTypeAttr.cpp b/bindings/Python/Generated/AST/CoroReturnTypeAttr.cpp
index 2f963f5bd..adbfe93d6 100644
--- a/bindings/Python/Generated/AST/CoroReturnTypeAttr.cpp
+++ b/bindings/Python/Generated/AST/CoroReturnTypeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CoroWrapperAttr.cpp b/bindings/Python/Generated/AST/CoroWrapperAttr.cpp
index b97dddc7b..f5f4cf5ac 100644
--- a/bindings/Python/Generated/AST/CoroWrapperAttr.cpp
+++ b/bindings/Python/Generated/AST/CoroWrapperAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CoroutineBodyStmt.cpp b/bindings/Python/Generated/AST/CoroutineBodyStmt.cpp
index c952bf510..5a5e617a9 100644
--- a/bindings/Python/Generated/AST/CoroutineBodyStmt.cpp
+++ b/bindings/Python/Generated/AST/CoroutineBodyStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -407,67 +406,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CoroutineBodyStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CoroutineBodyStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -531,6 +469,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CoroutineBodyStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CoroutineBodyStmt::from"),
+  },
   {
     "nth_parameter_move",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/CoroutineSuspendExpr.cpp b/bindings/Python/Generated/AST/CoroutineSuspendExpr.cpp
index 7904d8f77..a9c6ccd95 100644
--- a/bindings/Python/Generated/AST/CoroutineSuspendExpr.cpp
+++ b/bindings/Python/Generated/AST/CoroutineSuspendExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -302,18 +301,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::CoroutineSuspendExpr::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CoroutineSuspendExpr::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CoroutineSuspendExpr::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -339,7 +376,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -362,52 +399,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CoroutineSuspendExpr::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CoroutineSuspendExpr::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CoroutineSuspendExpr::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/CountedByAttr.cpp b/bindings/Python/Generated/AST/CountedByAttr.cpp
index bd744af6d..0d6c95c59 100644
--- a/bindings/Python/Generated/AST/CountedByAttr.cpp
+++ b/bindings/Python/Generated/AST/CountedByAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/CoyieldExpr.cpp b/bindings/Python/Generated/AST/CoyieldExpr.cpp
index 1f3849262..56daea894 100644
--- a/bindings/Python/Generated/AST/CoyieldExpr.cpp
+++ b/bindings/Python/Generated/AST/CoyieldExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CoyieldExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::CoyieldExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::CoyieldExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::CoyieldExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/DLLExportAttr.cpp b/bindings/Python/Generated/AST/DLLExportAttr.cpp
index 3f1e432df..5ee1c53ae 100644
--- a/bindings/Python/Generated/AST/DLLExportAttr.cpp
+++ b/bindings/Python/Generated/AST/DLLExportAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DLLExportStaticLocalAttr.cpp b/bindings/Python/Generated/AST/DLLExportStaticLocalAttr.cpp
index fb59f6890..b339d3276 100644
--- a/bindings/Python/Generated/AST/DLLExportStaticLocalAttr.cpp
+++ b/bindings/Python/Generated/AST/DLLExportStaticLocalAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DLLImportAttr.cpp b/bindings/Python/Generated/AST/DLLImportAttr.cpp
index e2bdab0a5..fc9b79068 100644
--- a/bindings/Python/Generated/AST/DLLImportAttr.cpp
+++ b/bindings/Python/Generated/AST/DLLImportAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DLLImportStaticLocalAttr.cpp b/bindings/Python/Generated/AST/DLLImportStaticLocalAttr.cpp
index 555fd1a60..063236856 100644
--- a/bindings/Python/Generated/AST/DLLImportStaticLocalAttr.cpp
+++ b/bindings/Python/Generated/AST/DLLImportStaticLocalAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DecayedType.cpp b/bindings/Python/Generated/AST/DecayedType.cpp
index 9fd8c59b3..014b0b149 100644
--- a/bindings/Python/Generated/AST/DecayedType.cpp
+++ b/bindings/Python/Generated/AST/DecayedType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -274,7 +273,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/Decl.cpp b/bindings/Python/Generated/AST/Decl.cpp
index f939dd637..e45be069d 100644
--- a/bindings/Python/Generated/AST/Decl.cpp
+++ b/bindings/Python/Generated/AST/Decl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -1073,18 +1072,35 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::Decl::containing"),
   },
   {
-    "FROM",
+    "by_id",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::Decl::by_id"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -1110,7 +1126,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -1133,31 +1149,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::Decl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::Decl::by_id"),
-  },
   {
     "nth_attribute",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/DeclOrStmtAttr.cpp b/bindings/Python/Generated/AST/DeclOrStmtAttr.cpp
index ba2488ec5..213375633 100644
--- a/bindings/Python/Generated/AST/DeclOrStmtAttr.cpp
+++ b/bindings/Python/Generated/AST/DeclOrStmtAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -275,7 +274,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DeclRefExpr.cpp b/bindings/Python/Generated/AST/DeclRefExpr.cpp
index c19b31ac3..f5206bf43 100644
--- a/bindings/Python/Generated/AST/DeclRefExpr.cpp
+++ b/bindings/Python/Generated/AST/DeclRefExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -337,67 +336,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DeclRefExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DeclRefExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -461,6 +399,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DeclRefExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DeclRefExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/DeclStmt.cpp b/bindings/Python/Generated/AST/DeclStmt.cpp
index ef5a8ce93..b38fa81d0 100644
--- a/bindings/Python/Generated/AST/DeclStmt.cpp
+++ b/bindings/Python/Generated/AST/DeclStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DeclStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DeclStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DeclStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DeclStmt::from"),
+  },
   {
     "nth_declaration",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/DeclaratorDecl.cpp b/bindings/Python/Generated/AST/DeclaratorDecl.cpp
index 7fb6afc6b..7c54103fe 100644
--- a/bindings/Python/Generated/AST/DeclaratorDecl.cpp
+++ b/bindings/Python/Generated/AST/DeclaratorDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -396,18 +395,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::DeclaratorDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DeclaratorDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DeclaratorDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -433,7 +470,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -456,52 +493,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DeclaratorDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DeclaratorDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DeclaratorDecl::from_base"),
-  },
   {
     "nth_template_parameter_list",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/DecltypeType.cpp b/bindings/Python/Generated/AST/DecltypeType.cpp
index c3e9e1e7b..60c857730 100644
--- a/bindings/Python/Generated/AST/DecltypeType.cpp
+++ b/bindings/Python/Generated/AST/DecltypeType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DecompositionDecl.cpp b/bindings/Python/Generated/AST/DecompositionDecl.cpp
index 834ece571..b021e39a7 100644
--- a/bindings/Python/Generated/AST/DecompositionDecl.cpp
+++ b/bindings/Python/Generated/AST/DecompositionDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DecompositionDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DecompositionDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DecompositionDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DecompositionDecl::from"),
+  },
   {
     "nth_binding",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/DeducedTemplateSpecializationType.cpp b/bindings/Python/Generated/AST/DeducedTemplateSpecializationType.cpp
index 94f4be0fa..2dc76a4e7 100644
--- a/bindings/Python/Generated/AST/DeducedTemplateSpecializationType.cpp
+++ b/bindings/Python/Generated/AST/DeducedTemplateSpecializationType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -264,7 +263,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DeducedType.cpp b/bindings/Python/Generated/AST/DeducedType.cpp
index 251d4164b..21f847e17 100644
--- a/bindings/Python/Generated/AST/DeducedType.cpp
+++ b/bindings/Python/Generated/AST/DeducedType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -281,7 +280,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DefaultStmt.cpp b/bindings/Python/Generated/AST/DefaultStmt.cpp
index 9d0e4b18a..9621f9014 100644
--- a/bindings/Python/Generated/AST/DefaultStmt.cpp
+++ b/bindings/Python/Generated/AST/DefaultStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DefaultStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DefaultStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DefaultStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DefaultStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/DependentAddressSpaceType.cpp b/bindings/Python/Generated/AST/DependentAddressSpaceType.cpp
index 0e9bbe282..16c5053f2 100644
--- a/bindings/Python/Generated/AST/DependentAddressSpaceType.cpp
+++ b/bindings/Python/Generated/AST/DependentAddressSpaceType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -304,7 +303,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DependentBitIntType.cpp b/bindings/Python/Generated/AST/DependentBitIntType.cpp
index 8d94efa1d..cddc4581c 100644
--- a/bindings/Python/Generated/AST/DependentBitIntType.cpp
+++ b/bindings/Python/Generated/AST/DependentBitIntType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -304,7 +303,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DependentCoawaitExpr.cpp b/bindings/Python/Generated/AST/DependentCoawaitExpr.cpp
index 76c516530..9fe2f368a 100644
--- a/bindings/Python/Generated/AST/DependentCoawaitExpr.cpp
+++ b/bindings/Python/Generated/AST/DependentCoawaitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DependentCoawaitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DependentCoawaitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DependentCoawaitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DependentCoawaitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/DependentNameType.cpp b/bindings/Python/Generated/AST/DependentNameType.cpp
index 2fbce83a3..a12278b62 100644
--- a/bindings/Python/Generated/AST/DependentNameType.cpp
+++ b/bindings/Python/Generated/AST/DependentNameType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -274,7 +273,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DependentScopeDeclRefExpr.cpp b/bindings/Python/Generated/AST/DependentScopeDeclRefExpr.cpp
index db49af7e8..12ab97415 100644
--- a/bindings/Python/Generated/AST/DependentScopeDeclRefExpr.cpp
+++ b/bindings/Python/Generated/AST/DependentScopeDeclRefExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DependentScopeDeclRefExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DependentScopeDeclRefExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DependentScopeDeclRefExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DependentScopeDeclRefExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/DependentSizedArrayType.cpp b/bindings/Python/Generated/AST/DependentSizedArrayType.cpp
index 4a75182fd..b90957b73 100644
--- a/bindings/Python/Generated/AST/DependentSizedArrayType.cpp
+++ b/bindings/Python/Generated/AST/DependentSizedArrayType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -314,7 +313,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DependentSizedExtVectorType.cpp b/bindings/Python/Generated/AST/DependentSizedExtVectorType.cpp
index 880178eae..1b1291fa7 100644
--- a/bindings/Python/Generated/AST/DependentSizedExtVectorType.cpp
+++ b/bindings/Python/Generated/AST/DependentSizedExtVectorType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -304,7 +303,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DependentSizedMatrixType.cpp b/bindings/Python/Generated/AST/DependentSizedMatrixType.cpp
index 2708a910d..f730eed1f 100644
--- a/bindings/Python/Generated/AST/DependentSizedMatrixType.cpp
+++ b/bindings/Python/Generated/AST/DependentSizedMatrixType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DependentTemplateSpecializationType.cpp b/bindings/Python/Generated/AST/DependentTemplateSpecializationType.cpp
index 74a36f159..ab5d04312 100644
--- a/bindings/Python/Generated/AST/DependentTemplateSpecializationType.cpp
+++ b/bindings/Python/Generated/AST/DependentTemplateSpecializationType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DependentVectorType.cpp b/bindings/Python/Generated/AST/DependentVectorType.cpp
index 1052a936c..30e4c5331 100644
--- a/bindings/Python/Generated/AST/DependentVectorType.cpp
+++ b/bindings/Python/Generated/AST/DependentVectorType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -314,7 +313,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DeprecatedAttr.cpp b/bindings/Python/Generated/AST/DeprecatedAttr.cpp
index 4c3308c6d..142df8619 100644
--- a/bindings/Python/Generated/AST/DeprecatedAttr.cpp
+++ b/bindings/Python/Generated/AST/DeprecatedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -320,7 +319,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DesignatedInitExpr.cpp b/bindings/Python/Generated/AST/DesignatedInitExpr.cpp
index a4d504acb..78292c1e5 100644
--- a/bindings/Python/Generated/AST/DesignatedInitExpr.cpp
+++ b/bindings/Python/Generated/AST/DesignatedInitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -327,67 +326,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DesignatedInitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DesignatedInitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -451,6 +389,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DesignatedInitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DesignatedInitExpr::from"),
+  },
   {
     "nth_designator",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/DesignatedInitUpdateExpr.cpp b/bindings/Python/Generated/AST/DesignatedInitUpdateExpr.cpp
index 31be67628..fffbfa069 100644
--- a/bindings/Python/Generated/AST/DesignatedInitUpdateExpr.cpp
+++ b/bindings/Python/Generated/AST/DesignatedInitUpdateExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DesignatedInitUpdateExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DesignatedInitUpdateExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DesignatedInitUpdateExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DesignatedInitUpdateExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/Designator.cpp b/bindings/Python/Generated/AST/Designator.cpp
index e1ba81742..93e923c8a 100644
--- a/bindings/Python/Generated/AST/Designator.cpp
+++ b/bindings/Python/Generated/AST/Designator.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -377,7 +376,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DestructorAttr.cpp b/bindings/Python/Generated/AST/DestructorAttr.cpp
index 31f6cd027..17edff76f 100644
--- a/bindings/Python/Generated/AST/DestructorAttr.cpp
+++ b/bindings/Python/Generated/AST/DestructorAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DiagnoseAsBuiltinAttr.cpp b/bindings/Python/Generated/AST/DiagnoseAsBuiltinAttr.cpp
index d3ea13395..f6c329be7 100644
--- a/bindings/Python/Generated/AST/DiagnoseAsBuiltinAttr.cpp
+++ b/bindings/Python/Generated/AST/DiagnoseAsBuiltinAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DiagnoseIfAttr.cpp b/bindings/Python/Generated/AST/DiagnoseIfAttr.cpp
index 05aa0a9df..90a94e6db 100644
--- a/bindings/Python/Generated/AST/DiagnoseIfAttr.cpp
+++ b/bindings/Python/Generated/AST/DiagnoseIfAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -360,7 +359,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DisableSanitizerInstrumentationAttr.cpp b/bindings/Python/Generated/AST/DisableSanitizerInstrumentationAttr.cpp
index 55e5b229d..8bf363489 100644
--- a/bindings/Python/Generated/AST/DisableSanitizerInstrumentationAttr.cpp
+++ b/bindings/Python/Generated/AST/DisableSanitizerInstrumentationAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DisableTailCallsAttr.cpp b/bindings/Python/Generated/AST/DisableTailCallsAttr.cpp
index ccb90a1a8..01d4d540c 100644
--- a/bindings/Python/Generated/AST/DisableTailCallsAttr.cpp
+++ b/bindings/Python/Generated/AST/DisableTailCallsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/DoStmt.cpp b/bindings/Python/Generated/AST/DoStmt.cpp
index bef4df17b..711c0d615 100644
--- a/bindings/Python/Generated/AST/DoStmt.cpp
+++ b/bindings/Python/Generated/AST/DoStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DoStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::DoStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::DoStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::DoStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ElaboratedType.cpp b/bindings/Python/Generated/AST/ElaboratedType.cpp
index 3a357ce7b..7e4586e39 100644
--- a/bindings/Python/Generated/AST/ElaboratedType.cpp
+++ b/bindings/Python/Generated/AST/ElaboratedType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/EmptyBasesAttr.cpp b/bindings/Python/Generated/AST/EmptyBasesAttr.cpp
index 0c9103803..d699c1025 100644
--- a/bindings/Python/Generated/AST/EmptyBasesAttr.cpp
+++ b/bindings/Python/Generated/AST/EmptyBasesAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/EmptyDecl.cpp b/bindings/Python/Generated/AST/EmptyDecl.cpp
index 024c61f42..8910d36d6 100644
--- a/bindings/Python/Generated/AST/EmptyDecl.cpp
+++ b/bindings/Python/Generated/AST/EmptyDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::EmptyDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::EmptyDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::EmptyDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::EmptyDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/EnableIfAttr.cpp b/bindings/Python/Generated/AST/EnableIfAttr.cpp
index 77428e8c2..a3859c1c3 100644
--- a/bindings/Python/Generated/AST/EnableIfAttr.cpp
+++ b/bindings/Python/Generated/AST/EnableIfAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/EnforceTCBAttr.cpp b/bindings/Python/Generated/AST/EnforceTCBAttr.cpp
index bd107fec7..3a3caee27 100644
--- a/bindings/Python/Generated/AST/EnforceTCBAttr.cpp
+++ b/bindings/Python/Generated/AST/EnforceTCBAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/EnforceTCBLeafAttr.cpp b/bindings/Python/Generated/AST/EnforceTCBLeafAttr.cpp
index 4984dd63e..d40e9a82a 100644
--- a/bindings/Python/Generated/AST/EnforceTCBLeafAttr.cpp
+++ b/bindings/Python/Generated/AST/EnforceTCBLeafAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/EnumConstantDecl.cpp b/bindings/Python/Generated/AST/EnumConstantDecl.cpp
index da57d4dc9..f2f490840 100644
--- a/bindings/Python/Generated/AST/EnumConstantDecl.cpp
+++ b/bindings/Python/Generated/AST/EnumConstantDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::EnumConstantDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::EnumConstantDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::EnumConstantDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::EnumConstantDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/EnumDecl.cpp b/bindings/Python/Generated/AST/EnumDecl.cpp
index 12ebdc9c3..4b5579eb9 100644
--- a/bindings/Python/Generated/AST/EnumDecl.cpp
+++ b/bindings/Python/Generated/AST/EnumDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -377,67 +376,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::EnumDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::EnumDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -501,6 +439,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::EnumDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::EnumDecl::from"),
+  },
   {
     "nth_enumerator",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/EnumExtensibilityAttr.cpp b/bindings/Python/Generated/AST/EnumExtensibilityAttr.cpp
index 283a2bc4a..4b00875ef 100644
--- a/bindings/Python/Generated/AST/EnumExtensibilityAttr.cpp
+++ b/bindings/Python/Generated/AST/EnumExtensibilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/EnumType.cpp b/bindings/Python/Generated/AST/EnumType.cpp
index cb7f01745..98e8f479e 100644
--- a/bindings/Python/Generated/AST/EnumType.cpp
+++ b/bindings/Python/Generated/AST/EnumType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -274,7 +273,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ErrorAttr.cpp b/bindings/Python/Generated/AST/ErrorAttr.cpp
index 859a35ef6..8155ee551 100644
--- a/bindings/Python/Generated/AST/ErrorAttr.cpp
+++ b/bindings/Python/Generated/AST/ErrorAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -330,7 +329,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ExcludeFromExplicitInstantiationAttr.cpp b/bindings/Python/Generated/AST/ExcludeFromExplicitInstantiationAttr.cpp
index 36b8b4e63..08c1d65d6 100644
--- a/bindings/Python/Generated/AST/ExcludeFromExplicitInstantiationAttr.cpp
+++ b/bindings/Python/Generated/AST/ExcludeFromExplicitInstantiationAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ExclusiveTrylockFunctionAttr.cpp b/bindings/Python/Generated/AST/ExclusiveTrylockFunctionAttr.cpp
index 077258651..f9e073721 100644
--- a/bindings/Python/Generated/AST/ExclusiveTrylockFunctionAttr.cpp
+++ b/bindings/Python/Generated/AST/ExclusiveTrylockFunctionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ExplicitCastExpr.cpp b/bindings/Python/Generated/AST/ExplicitCastExpr.cpp
index 30f417433..1b31e77ca 100644
--- a/bindings/Python/Generated/AST/ExplicitCastExpr.cpp
+++ b/bindings/Python/Generated/AST/ExplicitCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -270,18 +269,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::ExplicitCastExpr::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ExplicitCastExpr::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ExplicitCastExpr::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -307,7 +344,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -330,52 +367,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExplicitCastExpr::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ExplicitCastExpr::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ExplicitCastExpr::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ExportDecl.cpp b/bindings/Python/Generated/AST/ExportDecl.cpp
index 06e432eeb..264ecd639 100644
--- a/bindings/Python/Generated/AST/ExportDecl.cpp
+++ b/bindings/Python/Generated/AST/ExportDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExportDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ExportDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExportDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ExportDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/Expr.cpp b/bindings/Python/Generated/AST/Expr.cpp
index d39bc9841..5bfe95d03 100644
--- a/bindings/Python/Generated/AST/Expr.cpp
+++ b/bindings/Python/Generated/AST/Expr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -1110,18 +1109,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::Expr::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::Expr::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::Expr::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -1147,7 +1184,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -1170,52 +1207,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::Expr::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::Expr::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::Expr::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ExprWithCleanups.cpp b/bindings/Python/Generated/AST/ExprWithCleanups.cpp
index dac3be9bb..45e8eb8f0 100644
--- a/bindings/Python/Generated/AST/ExprWithCleanups.cpp
+++ b/bindings/Python/Generated/AST/ExprWithCleanups.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExprWithCleanups::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ExprWithCleanups::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExprWithCleanups::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ExprWithCleanups::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ExpressionTraitExpr.cpp b/bindings/Python/Generated/AST/ExpressionTraitExpr.cpp
index 12d829dd9..514346d1d 100644
--- a/bindings/Python/Generated/AST/ExpressionTraitExpr.cpp
+++ b/bindings/Python/Generated/AST/ExpressionTraitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExpressionTraitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ExpressionTraitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExpressionTraitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ExpressionTraitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ExtVectorElementExpr.cpp b/bindings/Python/Generated/AST/ExtVectorElementExpr.cpp
index c8cbcc8ff..2a6be2599 100644
--- a/bindings/Python/Generated/AST/ExtVectorElementExpr.cpp
+++ b/bindings/Python/Generated/AST/ExtVectorElementExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExtVectorElementExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ExtVectorElementExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExtVectorElementExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ExtVectorElementExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ExtVectorType.cpp b/bindings/Python/Generated/AST/ExtVectorType.cpp
index ee63d35fb..763b57c50 100644
--- a/bindings/Python/Generated/AST/ExtVectorType.cpp
+++ b/bindings/Python/Generated/AST/ExtVectorType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -264,7 +263,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ExternCContextDecl.cpp b/bindings/Python/Generated/AST/ExternCContextDecl.cpp
index fe51e205c..21ba4f3e1 100644
--- a/bindings/Python/Generated/AST/ExternCContextDecl.cpp
+++ b/bindings/Python/Generated/AST/ExternCContextDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExternCContextDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ExternCContextDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ExternCContextDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ExternCContextDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ExternalSourceSymbolAttr.cpp b/bindings/Python/Generated/AST/ExternalSourceSymbolAttr.cpp
index 77169346d..dfabb8a70 100644
--- a/bindings/Python/Generated/AST/ExternalSourceSymbolAttr.cpp
+++ b/bindings/Python/Generated/AST/ExternalSourceSymbolAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -350,7 +349,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FallThroughAttr.cpp b/bindings/Python/Generated/AST/FallThroughAttr.cpp
index 726919099..40dd0eb4d 100644
--- a/bindings/Python/Generated/AST/FallThroughAttr.cpp
+++ b/bindings/Python/Generated/AST/FallThroughAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FastCallAttr.cpp b/bindings/Python/Generated/AST/FastCallAttr.cpp
index 9eff70200..8da428630 100644
--- a/bindings/Python/Generated/AST/FastCallAttr.cpp
+++ b/bindings/Python/Generated/AST/FastCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FieldDecl.cpp b/bindings/Python/Generated/AST/FieldDecl.cpp
index d2f14f5bc..a45dfcfe0 100644
--- a/bindings/Python/Generated/AST/FieldDecl.cpp
+++ b/bindings/Python/Generated/AST/FieldDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -425,67 +424,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FieldDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FieldDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -549,6 +487,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FieldDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FieldDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/FileScopeAsmDecl.cpp b/bindings/Python/Generated/AST/FileScopeAsmDecl.cpp
index 2d6d1c5b8..1e3405bb8 100644
--- a/bindings/Python/Generated/AST/FileScopeAsmDecl.cpp
+++ b/bindings/Python/Generated/AST/FileScopeAsmDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FileScopeAsmDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FileScopeAsmDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FileScopeAsmDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FileScopeAsmDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/FinalAttr.cpp b/bindings/Python/Generated/AST/FinalAttr.cpp
index 832751065..3592dbf02 100644
--- a/bindings/Python/Generated/AST/FinalAttr.cpp
+++ b/bindings/Python/Generated/AST/FinalAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FixedPointLiteral.cpp b/bindings/Python/Generated/AST/FixedPointLiteral.cpp
index 291866945..c8e4dd920 100644
--- a/bindings/Python/Generated/AST/FixedPointLiteral.cpp
+++ b/bindings/Python/Generated/AST/FixedPointLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FixedPointLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FixedPointLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FixedPointLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FixedPointLiteral::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/FlagEnumAttr.cpp b/bindings/Python/Generated/AST/FlagEnumAttr.cpp
index 3308e10a7..53f37437a 100644
--- a/bindings/Python/Generated/AST/FlagEnumAttr.cpp
+++ b/bindings/Python/Generated/AST/FlagEnumAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FlattenAttr.cpp b/bindings/Python/Generated/AST/FlattenAttr.cpp
index 62ec3a6cb..5f6ee0889 100644
--- a/bindings/Python/Generated/AST/FlattenAttr.cpp
+++ b/bindings/Python/Generated/AST/FlattenAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FloatingLiteral.cpp b/bindings/Python/Generated/AST/FloatingLiteral.cpp
index cb1a632ea..dcecc8604 100644
--- a/bindings/Python/Generated/AST/FloatingLiteral.cpp
+++ b/bindings/Python/Generated/AST/FloatingLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FloatingLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FloatingLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FloatingLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FloatingLiteral::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ForStmt.cpp b/bindings/Python/Generated/AST/ForStmt.cpp
index 296c08cd9..54868472a 100644
--- a/bindings/Python/Generated/AST/ForStmt.cpp
+++ b/bindings/Python/Generated/AST/ForStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -317,67 +316,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ForStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ForStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -441,6 +379,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ForStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ForStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/FormatArgAttr.cpp b/bindings/Python/Generated/AST/FormatArgAttr.cpp
index df0adae9f..271128c82 100644
--- a/bindings/Python/Generated/AST/FormatArgAttr.cpp
+++ b/bindings/Python/Generated/AST/FormatArgAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FormatAttr.cpp b/bindings/Python/Generated/AST/FormatAttr.cpp
index cf955625c..650512ff6 100644
--- a/bindings/Python/Generated/AST/FormatAttr.cpp
+++ b/bindings/Python/Generated/AST/FormatAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FriendDecl.cpp b/bindings/Python/Generated/AST/FriendDecl.cpp
index 7ab1fe78c..0b913dc6f 100644
--- a/bindings/Python/Generated/AST/FriendDecl.cpp
+++ b/bindings/Python/Generated/AST/FriendDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -327,67 +326,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FriendDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FriendDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -451,6 +389,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FriendDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FriendDecl::from"),
+  },
   {
     "nth_friend_type_template_parameter_list",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/FriendTemplateDecl.cpp b/bindings/Python/Generated/AST/FriendTemplateDecl.cpp
index 4df37ec12..8ffd6c201 100644
--- a/bindings/Python/Generated/AST/FriendTemplateDecl.cpp
+++ b/bindings/Python/Generated/AST/FriendTemplateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FriendTemplateDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FriendTemplateDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FriendTemplateDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FriendTemplateDecl::from"),
+  },
   {
     "nth_template_parameter_list",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/FullExpr.cpp b/bindings/Python/Generated/AST/FullExpr.cpp
index da61e2288..9d6c3502f 100644
--- a/bindings/Python/Generated/AST/FullExpr.cpp
+++ b/bindings/Python/Generated/AST/FullExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -242,18 +241,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::FullExpr::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FullExpr::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FullExpr::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -279,7 +316,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -302,52 +339,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FullExpr::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FullExpr::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FullExpr::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/FunctionDecl.cpp b/bindings/Python/Generated/AST/FunctionDecl.cpp
index d6be2f074..fca780c83 100644
--- a/bindings/Python/Generated/AST/FunctionDecl.cpp
+++ b/bindings/Python/Generated/AST/FunctionDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -1127,67 +1126,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FunctionDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FunctionDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -1251,6 +1189,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FunctionDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FunctionDecl::from"),
+  },
   {
     "nth_parameter",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/FunctionNoProtoType.cpp b/bindings/Python/Generated/AST/FunctionNoProtoType.cpp
index a75e0ab43..d8be7a38f 100644
--- a/bindings/Python/Generated/AST/FunctionNoProtoType.cpp
+++ b/bindings/Python/Generated/AST/FunctionNoProtoType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -274,7 +273,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FunctionParmPackExpr.cpp b/bindings/Python/Generated/AST/FunctionParmPackExpr.cpp
index dce427541..427833a3e 100644
--- a/bindings/Python/Generated/AST/FunctionParmPackExpr.cpp
+++ b/bindings/Python/Generated/AST/FunctionParmPackExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FunctionParmPackExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FunctionParmPackExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FunctionParmPackExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FunctionParmPackExpr::from"),
+  },
   {
     "nth_expansion",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/FunctionProtoType.cpp b/bindings/Python/Generated/AST/FunctionProtoType.cpp
index 8e594f0bd..2f3c6f78d 100644
--- a/bindings/Python/Generated/AST/FunctionProtoType.cpp
+++ b/bindings/Python/Generated/AST/FunctionProtoType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -494,7 +493,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FunctionReturnThunksAttr.cpp b/bindings/Python/Generated/AST/FunctionReturnThunksAttr.cpp
index 50c3abd07..ac3f5acaa 100644
--- a/bindings/Python/Generated/AST/FunctionReturnThunksAttr.cpp
+++ b/bindings/Python/Generated/AST/FunctionReturnThunksAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/FunctionTemplateDecl.cpp b/bindings/Python/Generated/AST/FunctionTemplateDecl.cpp
index 958eaa7d7..e5937c2bb 100644
--- a/bindings/Python/Generated/AST/FunctionTemplateDecl.cpp
+++ b/bindings/Python/Generated/AST/FunctionTemplateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FunctionTemplateDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::FunctionTemplateDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::FunctionTemplateDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::FunctionTemplateDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/FunctionType.cpp b/bindings/Python/Generated/AST/FunctionType.cpp
index 647e5e259..032479ca0 100644
--- a/bindings/Python/Generated/AST/FunctionType.cpp
+++ b/bindings/Python/Generated/AST/FunctionType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -351,7 +350,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/GCCAsmStmt.cpp b/bindings/Python/Generated/AST/GCCAsmStmt.cpp
index 2e56becf6..c0bdf55ca 100644
--- a/bindings/Python/Generated/AST/GCCAsmStmt.cpp
+++ b/bindings/Python/Generated/AST/GCCAsmStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -387,67 +386,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::GCCAsmStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::GCCAsmStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -511,6 +449,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::GCCAsmStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::GCCAsmStmt::from"),
+  },
   {
     "nth_label",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/GNUInlineAttr.cpp b/bindings/Python/Generated/AST/GNUInlineAttr.cpp
index 96d009c48..c5ba8428d 100644
--- a/bindings/Python/Generated/AST/GNUInlineAttr.cpp
+++ b/bindings/Python/Generated/AST/GNUInlineAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/GNUNullExpr.cpp b/bindings/Python/Generated/AST/GNUNullExpr.cpp
index af70774c0..b8e348799 100644
--- a/bindings/Python/Generated/AST/GNUNullExpr.cpp
+++ b/bindings/Python/Generated/AST/GNUNullExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::GNUNullExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::GNUNullExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::GNUNullExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::GNUNullExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/GenericSelectionExpr.cpp b/bindings/Python/Generated/AST/GenericSelectionExpr.cpp
index add604f67..9cdd5b189 100644
--- a/bindings/Python/Generated/AST/GenericSelectionExpr.cpp
+++ b/bindings/Python/Generated/AST/GenericSelectionExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -347,67 +346,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::GenericSelectionExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::GenericSelectionExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -471,6 +409,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::GenericSelectionExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::GenericSelectionExpr::from"),
+  },
   {
     "nth_association_expression",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/GotoStmt.cpp b/bindings/Python/Generated/AST/GotoStmt.cpp
index 07f30ead1..37f0af8d6 100644
--- a/bindings/Python/Generated/AST/GotoStmt.cpp
+++ b/bindings/Python/Generated/AST/GotoStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::GotoStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::GotoStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::GotoStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::GotoStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/GuardedByAttr.cpp b/bindings/Python/Generated/AST/GuardedByAttr.cpp
index b18627031..01ef30d33 100644
--- a/bindings/Python/Generated/AST/GuardedByAttr.cpp
+++ b/bindings/Python/Generated/AST/GuardedByAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/GuardedVarAttr.cpp b/bindings/Python/Generated/AST/GuardedVarAttr.cpp
index ab4ebba38..4c052e0a9 100644
--- a/bindings/Python/Generated/AST/GuardedVarAttr.cpp
+++ b/bindings/Python/Generated/AST/GuardedVarAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HIPManagedAttr.cpp b/bindings/Python/Generated/AST/HIPManagedAttr.cpp
index 8b8ed1828..1ccc34eff 100644
--- a/bindings/Python/Generated/AST/HIPManagedAttr.cpp
+++ b/bindings/Python/Generated/AST/HIPManagedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HLSLAnnotationAttr.cpp b/bindings/Python/Generated/AST/HLSLAnnotationAttr.cpp
index be5148f04..8a4b9a880 100644
--- a/bindings/Python/Generated/AST/HLSLAnnotationAttr.cpp
+++ b/bindings/Python/Generated/AST/HLSLAnnotationAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,7 +266,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HLSLBufferDecl.cpp b/bindings/Python/Generated/AST/HLSLBufferDecl.cpp
index fbb6a8496..cc14b686f 100644
--- a/bindings/Python/Generated/AST/HLSLBufferDecl.cpp
+++ b/bindings/Python/Generated/AST/HLSLBufferDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::HLSLBufferDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::HLSLBufferDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::HLSLBufferDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::HLSLBufferDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/HLSLGroupSharedAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/HLSLGroupSharedAddressSpaceAttr.cpp
index e6c3f8254..bbf9df8a6 100644
--- a/bindings/Python/Generated/AST/HLSLGroupSharedAddressSpaceAttr.cpp
+++ b/bindings/Python/Generated/AST/HLSLGroupSharedAddressSpaceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HLSLNumThreadsAttr.cpp b/bindings/Python/Generated/AST/HLSLNumThreadsAttr.cpp
index 9746aa2f8..e7e00ee60 100644
--- a/bindings/Python/Generated/AST/HLSLNumThreadsAttr.cpp
+++ b/bindings/Python/Generated/AST/HLSLNumThreadsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HLSLParamModifierAttr.cpp b/bindings/Python/Generated/AST/HLSLParamModifierAttr.cpp
index a73c4c43e..a54f43967 100644
--- a/bindings/Python/Generated/AST/HLSLParamModifierAttr.cpp
+++ b/bindings/Python/Generated/AST/HLSLParamModifierAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -350,7 +349,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HLSLResourceAttr.cpp b/bindings/Python/Generated/AST/HLSLResourceAttr.cpp
index 4e08f1992..c1a81256a 100644
--- a/bindings/Python/Generated/AST/HLSLResourceAttr.cpp
+++ b/bindings/Python/Generated/AST/HLSLResourceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HLSLResourceBindingAttr.cpp b/bindings/Python/Generated/AST/HLSLResourceBindingAttr.cpp
index 64b8c5d28..8d36ea176 100644
--- a/bindings/Python/Generated/AST/HLSLResourceBindingAttr.cpp
+++ b/bindings/Python/Generated/AST/HLSLResourceBindingAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -320,7 +319,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HLSLSV_DispatchThreadIDAttr.cpp b/bindings/Python/Generated/AST/HLSLSV_DispatchThreadIDAttr.cpp
index e514fc731..c3f37c031 100644
--- a/bindings/Python/Generated/AST/HLSLSV_DispatchThreadIDAttr.cpp
+++ b/bindings/Python/Generated/AST/HLSLSV_DispatchThreadIDAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HLSLSV_GroupIndexAttr.cpp b/bindings/Python/Generated/AST/HLSLSV_GroupIndexAttr.cpp
index 7c785963c..53f4511f4 100644
--- a/bindings/Python/Generated/AST/HLSLSV_GroupIndexAttr.cpp
+++ b/bindings/Python/Generated/AST/HLSLSV_GroupIndexAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HLSLShaderAttr.cpp b/bindings/Python/Generated/AST/HLSLShaderAttr.cpp
index 96483d5f5..3cafcad79 100644
--- a/bindings/Python/Generated/AST/HLSLShaderAttr.cpp
+++ b/bindings/Python/Generated/AST/HLSLShaderAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/HotAttr.cpp b/bindings/Python/Generated/AST/HotAttr.cpp
index 3251fe68d..4150ec382 100644
--- a/bindings/Python/Generated/AST/HotAttr.cpp
+++ b/bindings/Python/Generated/AST/HotAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/IBActionAttr.cpp b/bindings/Python/Generated/AST/IBActionAttr.cpp
index a6d98fdab..d858e9343 100644
--- a/bindings/Python/Generated/AST/IBActionAttr.cpp
+++ b/bindings/Python/Generated/AST/IBActionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/IBOutletAttr.cpp b/bindings/Python/Generated/AST/IBOutletAttr.cpp
index fd04f5dfa..e1114a784 100644
--- a/bindings/Python/Generated/AST/IBOutletAttr.cpp
+++ b/bindings/Python/Generated/AST/IBOutletAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/IBOutletCollectionAttr.cpp b/bindings/Python/Generated/AST/IBOutletCollectionAttr.cpp
index fa543a9d0..3d9f2ebd8 100644
--- a/bindings/Python/Generated/AST/IBOutletCollectionAttr.cpp
+++ b/bindings/Python/Generated/AST/IBOutletCollectionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/IFuncAttr.cpp b/bindings/Python/Generated/AST/IFuncAttr.cpp
index 10de3af5a..dfa251388 100644
--- a/bindings/Python/Generated/AST/IFuncAttr.cpp
+++ b/bindings/Python/Generated/AST/IFuncAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/IfStmt.cpp b/bindings/Python/Generated/AST/IfStmt.cpp
index 1acc06606..c53dc09e1 100644
--- a/bindings/Python/Generated/AST/IfStmt.cpp
+++ b/bindings/Python/Generated/AST/IfStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -427,67 +426,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::IfStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::IfStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -551,6 +489,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::IfStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::IfStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ImaginaryLiteral.cpp b/bindings/Python/Generated/AST/ImaginaryLiteral.cpp
index b5117182d..07318eca5 100644
--- a/bindings/Python/Generated/AST/ImaginaryLiteral.cpp
+++ b/bindings/Python/Generated/AST/ImaginaryLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImaginaryLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ImaginaryLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImaginaryLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ImaginaryLiteral::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ImplicitCastExpr.cpp b/bindings/Python/Generated/AST/ImplicitCastExpr.cpp
index 01a3df28b..61d362978 100644
--- a/bindings/Python/Generated/AST/ImplicitCastExpr.cpp
+++ b/bindings/Python/Generated/AST/ImplicitCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImplicitCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ImplicitCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImplicitCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ImplicitCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ImplicitConceptSpecializationDecl.cpp b/bindings/Python/Generated/AST/ImplicitConceptSpecializationDecl.cpp
index 05a0cf9d0..da63ff7d4 100644
--- a/bindings/Python/Generated/AST/ImplicitConceptSpecializationDecl.cpp
+++ b/bindings/Python/Generated/AST/ImplicitConceptSpecializationDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImplicitConceptSpecializationDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ImplicitConceptSpecializationDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImplicitConceptSpecializationDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ImplicitConceptSpecializationDecl::from"),
+  },
   {
     "nth_template_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ImplicitParamDecl.cpp b/bindings/Python/Generated/AST/ImplicitParamDecl.cpp
index eae8a2a78..1089f2c3b 100644
--- a/bindings/Python/Generated/AST/ImplicitParamDecl.cpp
+++ b/bindings/Python/Generated/AST/ImplicitParamDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImplicitParamDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ImplicitParamDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImplicitParamDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ImplicitParamDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ImplicitValueInitExpr.cpp b/bindings/Python/Generated/AST/ImplicitValueInitExpr.cpp
index 2fcc6eecd..576ec164b 100644
--- a/bindings/Python/Generated/AST/ImplicitValueInitExpr.cpp
+++ b/bindings/Python/Generated/AST/ImplicitValueInitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImplicitValueInitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ImplicitValueInitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImplicitValueInitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ImplicitValueInitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ImportDecl.cpp b/bindings/Python/Generated/AST/ImportDecl.cpp
index 5bee30f80..c307ae87a 100644
--- a/bindings/Python/Generated/AST/ImportDecl.cpp
+++ b/bindings/Python/Generated/AST/ImportDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImportDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ImportDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ImportDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ImportDecl::from"),
+  },
   {
     "nth_identifier_token",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/IncompleteArrayType.cpp b/bindings/Python/Generated/AST/IncompleteArrayType.cpp
index fa313f8d5..4a77d9134 100644
--- a/bindings/Python/Generated/AST/IncompleteArrayType.cpp
+++ b/bindings/Python/Generated/AST/IncompleteArrayType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -274,7 +273,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/IndirectFieldDecl.cpp b/bindings/Python/Generated/AST/IndirectFieldDecl.cpp
index bdb8e8ee3..cc4ae3433 100644
--- a/bindings/Python/Generated/AST/IndirectFieldDecl.cpp
+++ b/bindings/Python/Generated/AST/IndirectFieldDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::IndirectFieldDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::IndirectFieldDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::IndirectFieldDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::IndirectFieldDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/IndirectGotoStmt.cpp b/bindings/Python/Generated/AST/IndirectGotoStmt.cpp
index 49608659c..4c4281ede 100644
--- a/bindings/Python/Generated/AST/IndirectGotoStmt.cpp
+++ b/bindings/Python/Generated/AST/IndirectGotoStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::IndirectGotoStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::IndirectGotoStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::IndirectGotoStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::IndirectGotoStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/InheritableAttr.cpp b/bindings/Python/Generated/AST/InheritableAttr.cpp
index 1b5a02526..cf8edbc3d 100644
--- a/bindings/Python/Generated/AST/InheritableAttr.cpp
+++ b/bindings/Python/Generated/AST/InheritableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -1573,7 +1572,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/InheritableParamAttr.cpp b/bindings/Python/Generated/AST/InheritableParamAttr.cpp
index d0f2bfa96..a04b1bc1f 100644
--- a/bindings/Python/Generated/AST/InheritableParamAttr.cpp
+++ b/bindings/Python/Generated/AST/InheritableParamAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -311,7 +310,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/InitListExpr.cpp b/bindings/Python/Generated/AST/InitListExpr.cpp
index 5ba12cb57..9a77de5f3 100644
--- a/bindings/Python/Generated/AST/InitListExpr.cpp
+++ b/bindings/Python/Generated/AST/InitListExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -387,67 +386,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::InitListExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::InitListExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -511,6 +449,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::InitListExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::InitListExpr::from"),
+  },
   {
     "nth_initializer",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/InitPriorityAttr.cpp b/bindings/Python/Generated/AST/InitPriorityAttr.cpp
index 37047c919..86a163a0c 100644
--- a/bindings/Python/Generated/AST/InitPriorityAttr.cpp
+++ b/bindings/Python/Generated/AST/InitPriorityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/InitSegAttr.cpp b/bindings/Python/Generated/AST/InitSegAttr.cpp
index 8be176bb2..3311d2a77 100644
--- a/bindings/Python/Generated/AST/InitSegAttr.cpp
+++ b/bindings/Python/Generated/AST/InitSegAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/InjectedClassNameType.cpp b/bindings/Python/Generated/AST/InjectedClassNameType.cpp
index aa4bbf147..1162b081d 100644
--- a/bindings/Python/Generated/AST/InjectedClassNameType.cpp
+++ b/bindings/Python/Generated/AST/InjectedClassNameType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -304,7 +303,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/IntegerLiteral.cpp b/bindings/Python/Generated/AST/IntegerLiteral.cpp
index 83f023c42..7fb1e5369 100644
--- a/bindings/Python/Generated/AST/IntegerLiteral.cpp
+++ b/bindings/Python/Generated/AST/IntegerLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::IntegerLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::IntegerLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::IntegerLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::IntegerLiteral::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/IntelOclBiccAttr.cpp b/bindings/Python/Generated/AST/IntelOclBiccAttr.cpp
index cbea7c12c..91d0beb23 100644
--- a/bindings/Python/Generated/AST/IntelOclBiccAttr.cpp
+++ b/bindings/Python/Generated/AST/IntelOclBiccAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/InternalLinkageAttr.cpp b/bindings/Python/Generated/AST/InternalLinkageAttr.cpp
index 92a918b4c..e88115233 100644
--- a/bindings/Python/Generated/AST/InternalLinkageAttr.cpp
+++ b/bindings/Python/Generated/AST/InternalLinkageAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LTOVisibilityPublicAttr.cpp b/bindings/Python/Generated/AST/LTOVisibilityPublicAttr.cpp
index 0b6143369..6c39c1b78 100644
--- a/bindings/Python/Generated/AST/LTOVisibilityPublicAttr.cpp
+++ b/bindings/Python/Generated/AST/LTOVisibilityPublicAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LValueReferenceType.cpp b/bindings/Python/Generated/AST/LValueReferenceType.cpp
index c2876dfc1..4eeb5b2e7 100644
--- a/bindings/Python/Generated/AST/LValueReferenceType.cpp
+++ b/bindings/Python/Generated/AST/LValueReferenceType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -274,7 +273,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LabelDecl.cpp b/bindings/Python/Generated/AST/LabelDecl.cpp
index a224d0477..b6be347c3 100644
--- a/bindings/Python/Generated/AST/LabelDecl.cpp
+++ b/bindings/Python/Generated/AST/LabelDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LabelDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::LabelDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LabelDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::LabelDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/LabelStmt.cpp b/bindings/Python/Generated/AST/LabelStmt.cpp
index e31b04897..3a44beef9 100644
--- a/bindings/Python/Generated/AST/LabelStmt.cpp
+++ b/bindings/Python/Generated/AST/LabelStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LabelStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::LabelStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LabelStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::LabelStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/LambdaExpr.cpp b/bindings/Python/Generated/AST/LambdaExpr.cpp
index 7d98b5c44..68fa0a5c2 100644
--- a/bindings/Python/Generated/AST/LambdaExpr.cpp
+++ b/bindings/Python/Generated/AST/LambdaExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -387,67 +386,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LambdaExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::LambdaExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -511,6 +449,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LambdaExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::LambdaExpr::from"),
+  },
   {
     "nth_explicit_template_parameter",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/LayoutVersionAttr.cpp b/bindings/Python/Generated/AST/LayoutVersionAttr.cpp
index f359240ba..663dffe6c 100644
--- a/bindings/Python/Generated/AST/LayoutVersionAttr.cpp
+++ b/bindings/Python/Generated/AST/LayoutVersionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LeafAttr.cpp b/bindings/Python/Generated/AST/LeafAttr.cpp
index a73ab5ed3..27c387739 100644
--- a/bindings/Python/Generated/AST/LeafAttr.cpp
+++ b/bindings/Python/Generated/AST/LeafAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LifetimeBoundAttr.cpp b/bindings/Python/Generated/AST/LifetimeBoundAttr.cpp
index b9ea8210f..7177f7071 100644
--- a/bindings/Python/Generated/AST/LifetimeBoundAttr.cpp
+++ b/bindings/Python/Generated/AST/LifetimeBoundAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LifetimeExtendedTemporaryDecl.cpp b/bindings/Python/Generated/AST/LifetimeExtendedTemporaryDecl.cpp
index cb5986064..28d81f34f 100644
--- a/bindings/Python/Generated/AST/LifetimeExtendedTemporaryDecl.cpp
+++ b/bindings/Python/Generated/AST/LifetimeExtendedTemporaryDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LifetimeExtendedTemporaryDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::LifetimeExtendedTemporaryDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LifetimeExtendedTemporaryDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::LifetimeExtendedTemporaryDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/LikelyAttr.cpp b/bindings/Python/Generated/AST/LikelyAttr.cpp
index 5ce45cd0c..5a033964c 100644
--- a/bindings/Python/Generated/AST/LikelyAttr.cpp
+++ b/bindings/Python/Generated/AST/LikelyAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LinkageSpecDecl.cpp b/bindings/Python/Generated/AST/LinkageSpecDecl.cpp
index bc47df70a..58a66d12a 100644
--- a/bindings/Python/Generated/AST/LinkageSpecDecl.cpp
+++ b/bindings/Python/Generated/AST/LinkageSpecDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LinkageSpecDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::LinkageSpecDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::LinkageSpecDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::LinkageSpecDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/LoaderUninitializedAttr.cpp b/bindings/Python/Generated/AST/LoaderUninitializedAttr.cpp
index d270bedec..04bf23625 100644
--- a/bindings/Python/Generated/AST/LoaderUninitializedAttr.cpp
+++ b/bindings/Python/Generated/AST/LoaderUninitializedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LockReturnedAttr.cpp b/bindings/Python/Generated/AST/LockReturnedAttr.cpp
index 6ccc258b4..dbddcd465 100644
--- a/bindings/Python/Generated/AST/LockReturnedAttr.cpp
+++ b/bindings/Python/Generated/AST/LockReturnedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LocksExcludedAttr.cpp b/bindings/Python/Generated/AST/LocksExcludedAttr.cpp
index 154433e63..a086e3463 100644
--- a/bindings/Python/Generated/AST/LocksExcludedAttr.cpp
+++ b/bindings/Python/Generated/AST/LocksExcludedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/LoopHintAttr.cpp b/bindings/Python/Generated/AST/LoopHintAttr.cpp
index aad7f58be..cb0c667e8 100644
--- a/bindings/Python/Generated/AST/LoopHintAttr.cpp
+++ b/bindings/Python/Generated/AST/LoopHintAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -320,7 +319,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/M68kInterruptAttr.cpp b/bindings/Python/Generated/AST/M68kInterruptAttr.cpp
index 114707a2c..66e9d0d5f 100644
--- a/bindings/Python/Generated/AST/M68kInterruptAttr.cpp
+++ b/bindings/Python/Generated/AST/M68kInterruptAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/M68kRTDAttr.cpp b/bindings/Python/Generated/AST/M68kRTDAttr.cpp
index ae2a84b5f..ff6186695 100644
--- a/bindings/Python/Generated/AST/M68kRTDAttr.cpp
+++ b/bindings/Python/Generated/AST/M68kRTDAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MIGServerRoutineAttr.cpp b/bindings/Python/Generated/AST/MIGServerRoutineAttr.cpp
index 1933f2d87..97646ff7b 100644
--- a/bindings/Python/Generated/AST/MIGServerRoutineAttr.cpp
+++ b/bindings/Python/Generated/AST/MIGServerRoutineAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MSABIAttr.cpp b/bindings/Python/Generated/AST/MSABIAttr.cpp
index fea2d9ef5..d6cdcb5c4 100644
--- a/bindings/Python/Generated/AST/MSABIAttr.cpp
+++ b/bindings/Python/Generated/AST/MSABIAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MSAllocatorAttr.cpp b/bindings/Python/Generated/AST/MSAllocatorAttr.cpp
index 0aa4ec983..475163e38 100644
--- a/bindings/Python/Generated/AST/MSAllocatorAttr.cpp
+++ b/bindings/Python/Generated/AST/MSAllocatorAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MSAsmStmt.cpp b/bindings/Python/Generated/AST/MSAsmStmt.cpp
index 78d813991..f9ca841c3 100644
--- a/bindings/Python/Generated/AST/MSAsmStmt.cpp
+++ b/bindings/Python/Generated/AST/MSAsmStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSAsmStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::MSAsmStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSAsmStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::MSAsmStmt::from"),
+  },
   {
     "nth_all_expression",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/MSConstexprAttr.cpp b/bindings/Python/Generated/AST/MSConstexprAttr.cpp
index aa86f7792..2be370cab 100644
--- a/bindings/Python/Generated/AST/MSConstexprAttr.cpp
+++ b/bindings/Python/Generated/AST/MSConstexprAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MSDependentExistsStmt.cpp b/bindings/Python/Generated/AST/MSDependentExistsStmt.cpp
index d024f356c..45b0401c2 100644
--- a/bindings/Python/Generated/AST/MSDependentExistsStmt.cpp
+++ b/bindings/Python/Generated/AST/MSDependentExistsStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSDependentExistsStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::MSDependentExistsStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSDependentExistsStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::MSDependentExistsStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/MSGuidDecl.cpp b/bindings/Python/Generated/AST/MSGuidDecl.cpp
index 493aea272..c84c99106 100644
--- a/bindings/Python/Generated/AST/MSGuidDecl.cpp
+++ b/bindings/Python/Generated/AST/MSGuidDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSGuidDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::MSGuidDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSGuidDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::MSGuidDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/MSInheritanceAttr.cpp b/bindings/Python/Generated/AST/MSInheritanceAttr.cpp
index 1735ccce0..8e747f70a 100644
--- a/bindings/Python/Generated/AST/MSInheritanceAttr.cpp
+++ b/bindings/Python/Generated/AST/MSInheritanceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MSNoVTableAttr.cpp b/bindings/Python/Generated/AST/MSNoVTableAttr.cpp
index 58f57a804..144ed003a 100644
--- a/bindings/Python/Generated/AST/MSNoVTableAttr.cpp
+++ b/bindings/Python/Generated/AST/MSNoVTableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MSP430InterruptAttr.cpp b/bindings/Python/Generated/AST/MSP430InterruptAttr.cpp
index f9b5c174e..af9e7d087 100644
--- a/bindings/Python/Generated/AST/MSP430InterruptAttr.cpp
+++ b/bindings/Python/Generated/AST/MSP430InterruptAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MSPropertyDecl.cpp b/bindings/Python/Generated/AST/MSPropertyDecl.cpp
index d0a8703ca..baf9499f2 100644
--- a/bindings/Python/Generated/AST/MSPropertyDecl.cpp
+++ b/bindings/Python/Generated/AST/MSPropertyDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSPropertyDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::MSPropertyDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSPropertyDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::MSPropertyDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/MSPropertyRefExpr.cpp b/bindings/Python/Generated/AST/MSPropertyRefExpr.cpp
index 9d167b4b8..fa0ac9808 100644
--- a/bindings/Python/Generated/AST/MSPropertyRefExpr.cpp
+++ b/bindings/Python/Generated/AST/MSPropertyRefExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSPropertyRefExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::MSPropertyRefExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSPropertyRefExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::MSPropertyRefExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/MSPropertySubscriptExpr.cpp b/bindings/Python/Generated/AST/MSPropertySubscriptExpr.cpp
index febc559b9..d944c6a5e 100644
--- a/bindings/Python/Generated/AST/MSPropertySubscriptExpr.cpp
+++ b/bindings/Python/Generated/AST/MSPropertySubscriptExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSPropertySubscriptExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::MSPropertySubscriptExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MSPropertySubscriptExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::MSPropertySubscriptExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/MSStructAttr.cpp b/bindings/Python/Generated/AST/MSStructAttr.cpp
index b414d847b..5591d4265 100644
--- a/bindings/Python/Generated/AST/MSStructAttr.cpp
+++ b/bindings/Python/Generated/AST/MSStructAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MSVtorDispAttr.cpp b/bindings/Python/Generated/AST/MSVtorDispAttr.cpp
index 4018fbca3..d5083b37b 100644
--- a/bindings/Python/Generated/AST/MSVtorDispAttr.cpp
+++ b/bindings/Python/Generated/AST/MSVtorDispAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MacroQualifiedType.cpp b/bindings/Python/Generated/AST/MacroQualifiedType.cpp
index 1bed34208..0fa38a2c1 100644
--- a/bindings/Python/Generated/AST/MacroQualifiedType.cpp
+++ b/bindings/Python/Generated/AST/MacroQualifiedType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MaterializeTemporaryExpr.cpp b/bindings/Python/Generated/AST/MaterializeTemporaryExpr.cpp
index 66c08bdca..951cbd218 100644
--- a/bindings/Python/Generated/AST/MaterializeTemporaryExpr.cpp
+++ b/bindings/Python/Generated/AST/MaterializeTemporaryExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MaterializeTemporaryExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::MaterializeTemporaryExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MaterializeTemporaryExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::MaterializeTemporaryExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/MatrixSubscriptExpr.cpp b/bindings/Python/Generated/AST/MatrixSubscriptExpr.cpp
index c62c90c6b..0850de0ab 100644
--- a/bindings/Python/Generated/AST/MatrixSubscriptExpr.cpp
+++ b/bindings/Python/Generated/AST/MatrixSubscriptExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MatrixSubscriptExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::MatrixSubscriptExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MatrixSubscriptExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::MatrixSubscriptExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/MatrixType.cpp b/bindings/Python/Generated/AST/MatrixType.cpp
index d15893b0a..5609712af 100644
--- a/bindings/Python/Generated/AST/MatrixType.cpp
+++ b/bindings/Python/Generated/AST/MatrixType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -271,7 +270,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MaxFieldAlignmentAttr.cpp b/bindings/Python/Generated/AST/MaxFieldAlignmentAttr.cpp
index a9e0d0c4a..5b6914699 100644
--- a/bindings/Python/Generated/AST/MaxFieldAlignmentAttr.cpp
+++ b/bindings/Python/Generated/AST/MaxFieldAlignmentAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MayAliasAttr.cpp b/bindings/Python/Generated/AST/MayAliasAttr.cpp
index f590ee527..fc3259cde 100644
--- a/bindings/Python/Generated/AST/MayAliasAttr.cpp
+++ b/bindings/Python/Generated/AST/MayAliasAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MaybeUndefAttr.cpp b/bindings/Python/Generated/AST/MaybeUndefAttr.cpp
index 134882a14..6e747dc3a 100644
--- a/bindings/Python/Generated/AST/MaybeUndefAttr.cpp
+++ b/bindings/Python/Generated/AST/MaybeUndefAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MemberExpr.cpp b/bindings/Python/Generated/AST/MemberExpr.cpp
index 7d70d3990..94507b778 100644
--- a/bindings/Python/Generated/AST/MemberExpr.cpp
+++ b/bindings/Python/Generated/AST/MemberExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -367,67 +366,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MemberExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::MemberExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -491,6 +429,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::MemberExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::MemberExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/MemberPointerType.cpp b/bindings/Python/Generated/AST/MemberPointerType.cpp
index 15cf92e03..f2f4474ce 100644
--- a/bindings/Python/Generated/AST/MemberPointerType.cpp
+++ b/bindings/Python/Generated/AST/MemberPointerType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -314,7 +313,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MicroMipsAttr.cpp b/bindings/Python/Generated/AST/MicroMipsAttr.cpp
index 56b23d707..ffc7c0706 100644
--- a/bindings/Python/Generated/AST/MicroMipsAttr.cpp
+++ b/bindings/Python/Generated/AST/MicroMipsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MinSizeAttr.cpp b/bindings/Python/Generated/AST/MinSizeAttr.cpp
index 5a73beabf..38e146ab5 100644
--- a/bindings/Python/Generated/AST/MinSizeAttr.cpp
+++ b/bindings/Python/Generated/AST/MinSizeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MinVectorWidthAttr.cpp b/bindings/Python/Generated/AST/MinVectorWidthAttr.cpp
index 515e64912..b877214ce 100644
--- a/bindings/Python/Generated/AST/MinVectorWidthAttr.cpp
+++ b/bindings/Python/Generated/AST/MinVectorWidthAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/Mips16Attr.cpp b/bindings/Python/Generated/AST/Mips16Attr.cpp
index 94a69b1d0..34ea66831 100644
--- a/bindings/Python/Generated/AST/Mips16Attr.cpp
+++ b/bindings/Python/Generated/AST/Mips16Attr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MipsInterruptAttr.cpp b/bindings/Python/Generated/AST/MipsInterruptAttr.cpp
index b443157c2..ca8ed6dfb 100644
--- a/bindings/Python/Generated/AST/MipsInterruptAttr.cpp
+++ b/bindings/Python/Generated/AST/MipsInterruptAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MipsLongCallAttr.cpp b/bindings/Python/Generated/AST/MipsLongCallAttr.cpp
index f1d8e3ce0..a316415d9 100644
--- a/bindings/Python/Generated/AST/MipsLongCallAttr.cpp
+++ b/bindings/Python/Generated/AST/MipsLongCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MipsShortCallAttr.cpp b/bindings/Python/Generated/AST/MipsShortCallAttr.cpp
index 2b7ff8b2e..ad4a1a99a 100644
--- a/bindings/Python/Generated/AST/MipsShortCallAttr.cpp
+++ b/bindings/Python/Generated/AST/MipsShortCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ModeAttr.cpp b/bindings/Python/Generated/AST/ModeAttr.cpp
index 5d3ecad57..5f09a8aa9 100644
--- a/bindings/Python/Generated/AST/ModeAttr.cpp
+++ b/bindings/Python/Generated/AST/ModeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/MustTailAttr.cpp b/bindings/Python/Generated/AST/MustTailAttr.cpp
index 93fce5435..2a76f7787 100644
--- a/bindings/Python/Generated/AST/MustTailAttr.cpp
+++ b/bindings/Python/Generated/AST/MustTailAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NSConsumedAttr.cpp b/bindings/Python/Generated/AST/NSConsumedAttr.cpp
index c29b11fdb..97ad7446d 100644
--- a/bindings/Python/Generated/AST/NSConsumedAttr.cpp
+++ b/bindings/Python/Generated/AST/NSConsumedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NSConsumesSelfAttr.cpp b/bindings/Python/Generated/AST/NSConsumesSelfAttr.cpp
index 733406def..ab2050f30 100644
--- a/bindings/Python/Generated/AST/NSConsumesSelfAttr.cpp
+++ b/bindings/Python/Generated/AST/NSConsumesSelfAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NSErrorDomainAttr.cpp b/bindings/Python/Generated/AST/NSErrorDomainAttr.cpp
index 263f76c2d..2fda123df 100644
--- a/bindings/Python/Generated/AST/NSErrorDomainAttr.cpp
+++ b/bindings/Python/Generated/AST/NSErrorDomainAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NSReturnsAutoreleasedAttr.cpp b/bindings/Python/Generated/AST/NSReturnsAutoreleasedAttr.cpp
index b28c812fb..8ce149705 100644
--- a/bindings/Python/Generated/AST/NSReturnsAutoreleasedAttr.cpp
+++ b/bindings/Python/Generated/AST/NSReturnsAutoreleasedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NSReturnsNotRetainedAttr.cpp b/bindings/Python/Generated/AST/NSReturnsNotRetainedAttr.cpp
index a791eee2c..f99f38b58 100644
--- a/bindings/Python/Generated/AST/NSReturnsNotRetainedAttr.cpp
+++ b/bindings/Python/Generated/AST/NSReturnsNotRetainedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NSReturnsRetainedAttr.cpp b/bindings/Python/Generated/AST/NSReturnsRetainedAttr.cpp
index 2382689ef..3b36582e0 100644
--- a/bindings/Python/Generated/AST/NSReturnsRetainedAttr.cpp
+++ b/bindings/Python/Generated/AST/NSReturnsRetainedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NVPTXKernelAttr.cpp b/bindings/Python/Generated/AST/NVPTXKernelAttr.cpp
index b727096f7..6b3b086d5 100644
--- a/bindings/Python/Generated/AST/NVPTXKernelAttr.cpp
+++ b/bindings/Python/Generated/AST/NVPTXKernelAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NakedAttr.cpp b/bindings/Python/Generated/AST/NakedAttr.cpp
index dc141027a..fedad026e 100644
--- a/bindings/Python/Generated/AST/NakedAttr.cpp
+++ b/bindings/Python/Generated/AST/NakedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NamedDecl.cpp b/bindings/Python/Generated/AST/NamedDecl.cpp
index 11ef4c980..7eeaa0c8f 100644
--- a/bindings/Python/Generated/AST/NamedDecl.cpp
+++ b/bindings/Python/Generated/AST/NamedDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -636,18 +635,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::NamedDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::NamedDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::NamedDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -673,7 +710,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -696,52 +733,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NamedDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::NamedDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::NamedDecl::from_base"),
-  },
   {
     "qualified_name",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/NamespaceAliasDecl.cpp b/bindings/Python/Generated/AST/NamespaceAliasDecl.cpp
index bc57863aa..7b5f52f60 100644
--- a/bindings/Python/Generated/AST/NamespaceAliasDecl.cpp
+++ b/bindings/Python/Generated/AST/NamespaceAliasDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NamespaceAliasDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::NamespaceAliasDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NamespaceAliasDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::NamespaceAliasDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/NamespaceDecl.cpp b/bindings/Python/Generated/AST/NamespaceDecl.cpp
index 44616e054..6f1f5629e 100644
--- a/bindings/Python/Generated/AST/NamespaceDecl.cpp
+++ b/bindings/Python/Generated/AST/NamespaceDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NamespaceDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::NamespaceDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NamespaceDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::NamespaceDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/NoAliasAttr.cpp b/bindings/Python/Generated/AST/NoAliasAttr.cpp
index 34bbd746a..ea1673e8a 100644
--- a/bindings/Python/Generated/AST/NoAliasAttr.cpp
+++ b/bindings/Python/Generated/AST/NoAliasAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoBuiltinAttr.cpp b/bindings/Python/Generated/AST/NoBuiltinAttr.cpp
index bec6991e7..a4078b7e4 100644
--- a/bindings/Python/Generated/AST/NoBuiltinAttr.cpp
+++ b/bindings/Python/Generated/AST/NoBuiltinAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoCommonAttr.cpp b/bindings/Python/Generated/AST/NoCommonAttr.cpp
index fcb56eb89..99e15e056 100644
--- a/bindings/Python/Generated/AST/NoCommonAttr.cpp
+++ b/bindings/Python/Generated/AST/NoCommonAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoDebugAttr.cpp b/bindings/Python/Generated/AST/NoDebugAttr.cpp
index 9d2c5cf4c..2354e43cd 100644
--- a/bindings/Python/Generated/AST/NoDebugAttr.cpp
+++ b/bindings/Python/Generated/AST/NoDebugAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoDerefAttr.cpp b/bindings/Python/Generated/AST/NoDerefAttr.cpp
index 708dae363..5cfa275a4 100644
--- a/bindings/Python/Generated/AST/NoDerefAttr.cpp
+++ b/bindings/Python/Generated/AST/NoDerefAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoDestroyAttr.cpp b/bindings/Python/Generated/AST/NoDestroyAttr.cpp
index 4d326f44b..fbbe69c4c 100644
--- a/bindings/Python/Generated/AST/NoDestroyAttr.cpp
+++ b/bindings/Python/Generated/AST/NoDestroyAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoDuplicateAttr.cpp b/bindings/Python/Generated/AST/NoDuplicateAttr.cpp
index 1e13ec0a8..c0f932137 100644
--- a/bindings/Python/Generated/AST/NoDuplicateAttr.cpp
+++ b/bindings/Python/Generated/AST/NoDuplicateAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoEscapeAttr.cpp b/bindings/Python/Generated/AST/NoEscapeAttr.cpp
index 72d2922d1..55abb63fa 100644
--- a/bindings/Python/Generated/AST/NoEscapeAttr.cpp
+++ b/bindings/Python/Generated/AST/NoEscapeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoInitExpr.cpp b/bindings/Python/Generated/AST/NoInitExpr.cpp
index 6f66cfdf3..79c0950dd 100644
--- a/bindings/Python/Generated/AST/NoInitExpr.cpp
+++ b/bindings/Python/Generated/AST/NoInitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NoInitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::NoInitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NoInitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::NoInitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/NoInlineAttr.cpp b/bindings/Python/Generated/AST/NoInlineAttr.cpp
index aaac82430..06aed41c0 100644
--- a/bindings/Python/Generated/AST/NoInlineAttr.cpp
+++ b/bindings/Python/Generated/AST/NoInlineAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoInstrumentFunctionAttr.cpp b/bindings/Python/Generated/AST/NoInstrumentFunctionAttr.cpp
index 9bb5052f9..89b947491 100644
--- a/bindings/Python/Generated/AST/NoInstrumentFunctionAttr.cpp
+++ b/bindings/Python/Generated/AST/NoInstrumentFunctionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoMergeAttr.cpp b/bindings/Python/Generated/AST/NoMergeAttr.cpp
index 5a88a14ec..16e47301d 100644
--- a/bindings/Python/Generated/AST/NoMergeAttr.cpp
+++ b/bindings/Python/Generated/AST/NoMergeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoMicroMipsAttr.cpp b/bindings/Python/Generated/AST/NoMicroMipsAttr.cpp
index f72470781..a8b7601e8 100644
--- a/bindings/Python/Generated/AST/NoMicroMipsAttr.cpp
+++ b/bindings/Python/Generated/AST/NoMicroMipsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoMips16Attr.cpp b/bindings/Python/Generated/AST/NoMips16Attr.cpp
index a927e43bc..1172c2c6b 100644
--- a/bindings/Python/Generated/AST/NoMips16Attr.cpp
+++ b/bindings/Python/Generated/AST/NoMips16Attr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoProfileFunctionAttr.cpp b/bindings/Python/Generated/AST/NoProfileFunctionAttr.cpp
index 5b2bcfd42..242d35610 100644
--- a/bindings/Python/Generated/AST/NoProfileFunctionAttr.cpp
+++ b/bindings/Python/Generated/AST/NoProfileFunctionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoRandomizeLayoutAttr.cpp b/bindings/Python/Generated/AST/NoRandomizeLayoutAttr.cpp
index 8014214d0..d723ea401 100644
--- a/bindings/Python/Generated/AST/NoRandomizeLayoutAttr.cpp
+++ b/bindings/Python/Generated/AST/NoRandomizeLayoutAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoReturnAttr.cpp b/bindings/Python/Generated/AST/NoReturnAttr.cpp
index ed826d0be..db4053f61 100644
--- a/bindings/Python/Generated/AST/NoReturnAttr.cpp
+++ b/bindings/Python/Generated/AST/NoReturnAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoSanitizeAttr.cpp b/bindings/Python/Generated/AST/NoSanitizeAttr.cpp
index bd479c524..c444e8199 100644
--- a/bindings/Python/Generated/AST/NoSanitizeAttr.cpp
+++ b/bindings/Python/Generated/AST/NoSanitizeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoSpeculativeLoadHardeningAttr.cpp b/bindings/Python/Generated/AST/NoSpeculativeLoadHardeningAttr.cpp
index c56c4f225..7f61b278b 100644
--- a/bindings/Python/Generated/AST/NoSpeculativeLoadHardeningAttr.cpp
+++ b/bindings/Python/Generated/AST/NoSpeculativeLoadHardeningAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoSplitStackAttr.cpp b/bindings/Python/Generated/AST/NoSplitStackAttr.cpp
index 292ef5820..b518adfcb 100644
--- a/bindings/Python/Generated/AST/NoSplitStackAttr.cpp
+++ b/bindings/Python/Generated/AST/NoSplitStackAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoStackProtectorAttr.cpp b/bindings/Python/Generated/AST/NoStackProtectorAttr.cpp
index 7a8587cc2..93e6bc2e4 100644
--- a/bindings/Python/Generated/AST/NoStackProtectorAttr.cpp
+++ b/bindings/Python/Generated/AST/NoStackProtectorAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoThreadSafetyAnalysisAttr.cpp b/bindings/Python/Generated/AST/NoThreadSafetyAnalysisAttr.cpp
index 1fdef1aec..5c1dd0c0e 100644
--- a/bindings/Python/Generated/AST/NoThreadSafetyAnalysisAttr.cpp
+++ b/bindings/Python/Generated/AST/NoThreadSafetyAnalysisAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoThrowAttr.cpp b/bindings/Python/Generated/AST/NoThrowAttr.cpp
index db0cfdc34..e36db6e40 100644
--- a/bindings/Python/Generated/AST/NoThrowAttr.cpp
+++ b/bindings/Python/Generated/AST/NoThrowAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoUniqueAddressAttr.cpp b/bindings/Python/Generated/AST/NoUniqueAddressAttr.cpp
index b51308596..0817c3e49 100644
--- a/bindings/Python/Generated/AST/NoUniqueAddressAttr.cpp
+++ b/bindings/Python/Generated/AST/NoUniqueAddressAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NoUwtableAttr.cpp b/bindings/Python/Generated/AST/NoUwtableAttr.cpp
index 46723aa3d..626e68f29 100644
--- a/bindings/Python/Generated/AST/NoUwtableAttr.cpp
+++ b/bindings/Python/Generated/AST/NoUwtableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NonNullAttr.cpp b/bindings/Python/Generated/AST/NonNullAttr.cpp
index 3b6431820..157623ce4 100644
--- a/bindings/Python/Generated/AST/NonNullAttr.cpp
+++ b/bindings/Python/Generated/AST/NonNullAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NonTypeTemplateParmDecl.cpp b/bindings/Python/Generated/AST/NonTypeTemplateParmDecl.cpp
index e13afae0d..77f998fce 100644
--- a/bindings/Python/Generated/AST/NonTypeTemplateParmDecl.cpp
+++ b/bindings/Python/Generated/AST/NonTypeTemplateParmDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -357,67 +356,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NonTypeTemplateParmDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::NonTypeTemplateParmDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -481,6 +419,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NonTypeTemplateParmDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::NonTypeTemplateParmDecl::from"),
+  },
   {
     "nth_expansion_type",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/NotTailCalledAttr.cpp b/bindings/Python/Generated/AST/NotTailCalledAttr.cpp
index 4658e7823..38ca29dfd 100644
--- a/bindings/Python/Generated/AST/NotTailCalledAttr.cpp
+++ b/bindings/Python/Generated/AST/NotTailCalledAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/NullStmt.cpp b/bindings/Python/Generated/AST/NullStmt.cpp
index 263e910df..5b8de73c9 100644
--- a/bindings/Python/Generated/AST/NullStmt.cpp
+++ b/bindings/Python/Generated/AST/NullStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NullStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::NullStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::NullStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::NullStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPAllocateDecl.cpp b/bindings/Python/Generated/AST/OMPAllocateDecl.cpp
index 3877cd0f9..405426b45 100644
--- a/bindings/Python/Generated/AST/OMPAllocateDecl.cpp
+++ b/bindings/Python/Generated/AST/OMPAllocateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPAllocateDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPAllocateDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPAllocateDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPAllocateDecl::from"),
+  },
   {
     "nth_varlist",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/OMPAllocateDeclAttr.cpp b/bindings/Python/Generated/AST/OMPAllocateDeclAttr.cpp
index 1408a7808..e7ef39580 100644
--- a/bindings/Python/Generated/AST/OMPAllocateDeclAttr.cpp
+++ b/bindings/Python/Generated/AST/OMPAllocateDeclAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OMPArraySectionExpr.cpp b/bindings/Python/Generated/AST/OMPArraySectionExpr.cpp
index 60d3c069f..ad21bec10 100644
--- a/bindings/Python/Generated/AST/OMPArraySectionExpr.cpp
+++ b/bindings/Python/Generated/AST/OMPArraySectionExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPArraySectionExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPArraySectionExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPArraySectionExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPArraySectionExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPArrayShapingExpr.cpp b/bindings/Python/Generated/AST/OMPArrayShapingExpr.cpp
index 7d234128c..d2423d79c 100644
--- a/bindings/Python/Generated/AST/OMPArrayShapingExpr.cpp
+++ b/bindings/Python/Generated/AST/OMPArrayShapingExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPArrayShapingExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPArrayShapingExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPArrayShapingExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPArrayShapingExpr::from"),
+  },
   {
     "nth_dimension",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/OMPAtomicDirective.cpp b/bindings/Python/Generated/AST/OMPAtomicDirective.cpp
index 12dac1f5b..f1231d6ec 100644
--- a/bindings/Python/Generated/AST/OMPAtomicDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPAtomicDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -327,67 +326,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPAtomicDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPAtomicDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -451,6 +389,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPAtomicDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPAtomicDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPBarrierDirective.cpp b/bindings/Python/Generated/AST/OMPBarrierDirective.cpp
index 430fb1cf8..5df2c252a 100644
--- a/bindings/Python/Generated/AST/OMPBarrierDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPBarrierDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPBarrierDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPBarrierDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPBarrierDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPBarrierDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPCancelDirective.cpp b/bindings/Python/Generated/AST/OMPCancelDirective.cpp
index ac3d5f26d..8b5353458 100644
--- a/bindings/Python/Generated/AST/OMPCancelDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPCancelDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCancelDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPCancelDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCancelDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPCancelDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPCancellationPointDirective.cpp b/bindings/Python/Generated/AST/OMPCancellationPointDirective.cpp
index c47c547b2..e3545c780 100644
--- a/bindings/Python/Generated/AST/OMPCancellationPointDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPCancellationPointDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCancellationPointDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPCancellationPointDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCancellationPointDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPCancellationPointDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPCanonicalLoop.cpp b/bindings/Python/Generated/AST/OMPCanonicalLoop.cpp
index e35eb42dd..bfbffbd7d 100644
--- a/bindings/Python/Generated/AST/OMPCanonicalLoop.cpp
+++ b/bindings/Python/Generated/AST/OMPCanonicalLoop.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCanonicalLoop::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPCanonicalLoop::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCanonicalLoop::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPCanonicalLoop::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPCaptureKindAttr.cpp b/bindings/Python/Generated/AST/OMPCaptureKindAttr.cpp
index e0ee195af..2c801a25a 100644
--- a/bindings/Python/Generated/AST/OMPCaptureKindAttr.cpp
+++ b/bindings/Python/Generated/AST/OMPCaptureKindAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OMPCaptureNoInitAttr.cpp b/bindings/Python/Generated/AST/OMPCaptureNoInitAttr.cpp
index 9d72a8845..313086b6e 100644
--- a/bindings/Python/Generated/AST/OMPCaptureNoInitAttr.cpp
+++ b/bindings/Python/Generated/AST/OMPCaptureNoInitAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OMPCapturedExprDecl.cpp b/bindings/Python/Generated/AST/OMPCapturedExprDecl.cpp
index a5f487979..953cb118c 100644
--- a/bindings/Python/Generated/AST/OMPCapturedExprDecl.cpp
+++ b/bindings/Python/Generated/AST/OMPCapturedExprDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCapturedExprDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPCapturedExprDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCapturedExprDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPCapturedExprDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPCriticalDirective.cpp b/bindings/Python/Generated/AST/OMPCriticalDirective.cpp
index bb9947960..1d35be249 100644
--- a/bindings/Python/Generated/AST/OMPCriticalDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPCriticalDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCriticalDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPCriticalDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPCriticalDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPCriticalDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDeclarativeDirectiveDecl.cpp b/bindings/Python/Generated/AST/OMPDeclarativeDirectiveDecl.cpp
index eef8b9f19..8182d8546 100644
--- a/bindings/Python/Generated/AST/OMPDeclarativeDirectiveDecl.cpp
+++ b/bindings/Python/Generated/AST/OMPDeclarativeDirectiveDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -266,18 +265,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -303,7 +340,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -326,52 +363,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveDecl::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDeclarativeDirectiveValueDecl.cpp b/bindings/Python/Generated/AST/OMPDeclarativeDirectiveValueDecl.cpp
index 422df3584..a0045d92d 100644
--- a/bindings/Python/Generated/AST/OMPDeclarativeDirectiveValueDecl.cpp
+++ b/bindings/Python/Generated/AST/OMPDeclarativeDirectiveValueDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -258,18 +257,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveValueDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveValueDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveValueDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -295,7 +332,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -318,52 +355,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveValueDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveValueDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDeclarativeDirectiveValueDecl::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDeclareMapperDecl.cpp b/bindings/Python/Generated/AST/OMPDeclareMapperDecl.cpp
index c77185278..6d33e0384 100644
--- a/bindings/Python/Generated/AST/OMPDeclareMapperDecl.cpp
+++ b/bindings/Python/Generated/AST/OMPDeclareMapperDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDeclareMapperDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDeclareMapperDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDeclareMapperDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDeclareMapperDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDeclareReductionDecl.cpp b/bindings/Python/Generated/AST/OMPDeclareReductionDecl.cpp
index 318ed2507..123caf9a5 100644
--- a/bindings/Python/Generated/AST/OMPDeclareReductionDecl.cpp
+++ b/bindings/Python/Generated/AST/OMPDeclareReductionDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -337,67 +336,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDeclareReductionDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDeclareReductionDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -461,6 +399,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDeclareReductionDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDeclareReductionDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDeclareSimdDeclAttr.cpp b/bindings/Python/Generated/AST/OMPDeclareSimdDeclAttr.cpp
index 2fb5a4d66..e7e82c2a6 100644
--- a/bindings/Python/Generated/AST/OMPDeclareSimdDeclAttr.cpp
+++ b/bindings/Python/Generated/AST/OMPDeclareSimdDeclAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OMPDeclareTargetDeclAttr.cpp b/bindings/Python/Generated/AST/OMPDeclareTargetDeclAttr.cpp
index 57849039b..32b0d3d1c 100644
--- a/bindings/Python/Generated/AST/OMPDeclareTargetDeclAttr.cpp
+++ b/bindings/Python/Generated/AST/OMPDeclareTargetDeclAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -330,7 +329,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OMPDeclareVariantAttr.cpp b/bindings/Python/Generated/AST/OMPDeclareVariantAttr.cpp
index 766cf0bc0..8181c241f 100644
--- a/bindings/Python/Generated/AST/OMPDeclareVariantAttr.cpp
+++ b/bindings/Python/Generated/AST/OMPDeclareVariantAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OMPDepobjDirective.cpp b/bindings/Python/Generated/AST/OMPDepobjDirective.cpp
index e04e4fdc5..26ef75d0e 100644
--- a/bindings/Python/Generated/AST/OMPDepobjDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPDepobjDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDepobjDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDepobjDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDepobjDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDepobjDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDispatchDirective.cpp b/bindings/Python/Generated/AST/OMPDispatchDirective.cpp
index 0fdff25e0..1d730b8ea 100644
--- a/bindings/Python/Generated/AST/OMPDispatchDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPDispatchDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDispatchDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDispatchDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDispatchDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDispatchDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDistributeDirective.cpp b/bindings/Python/Generated/AST/OMPDistributeDirective.cpp
index 3453a90f3..281fa7f3e 100644
--- a/bindings/Python/Generated/AST/OMPDistributeDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPDistributeDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDistributeDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDistributeDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDistributeDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDistributeDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDistributeParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPDistributeParallelForDirective.cpp
index 86135e57b..7e05dc9a5 100644
--- a/bindings/Python/Generated/AST/OMPDistributeParallelForDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPDistributeParallelForDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDistributeParallelForDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDistributeParallelForDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDistributeParallelForDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDistributeParallelForDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDistributeParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPDistributeParallelForSimdDirective.cpp
index 5b1772cfe..d0360e1fb 100644
--- a/bindings/Python/Generated/AST/OMPDistributeParallelForSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPDistributeParallelForSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDistributeParallelForSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDistributeParallelForSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDistributeParallelForSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDistributeParallelForSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPDistributeSimdDirective.cpp b/bindings/Python/Generated/AST/OMPDistributeSimdDirective.cpp
index 216705a10..ade273c6f 100644
--- a/bindings/Python/Generated/AST/OMPDistributeSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPDistributeSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDistributeSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPDistributeSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPDistributeSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPDistributeSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPErrorDirective.cpp b/bindings/Python/Generated/AST/OMPErrorDirective.cpp
index b83cab57d..2a0608b36 100644
--- a/bindings/Python/Generated/AST/OMPErrorDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPErrorDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPErrorDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPErrorDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPErrorDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPErrorDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPExecutableDirective.cpp b/bindings/Python/Generated/AST/OMPExecutableDirective.cpp
index 224eec09f..2fcab1cec 100644
--- a/bindings/Python/Generated/AST/OMPExecutableDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPExecutableDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -572,18 +571,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::OMPExecutableDirective::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPExecutableDirective::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPExecutableDirective::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -609,7 +646,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -632,52 +669,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPExecutableDirective::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPExecutableDirective::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPExecutableDirective::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPFlushDirective.cpp b/bindings/Python/Generated/AST/OMPFlushDirective.cpp
index 0316a0aaa..51d906daf 100644
--- a/bindings/Python/Generated/AST/OMPFlushDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPFlushDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPFlushDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPFlushDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPFlushDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPFlushDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPForDirective.cpp b/bindings/Python/Generated/AST/OMPForDirective.cpp
index 7f4ea0ba4..74d574ae9 100644
--- a/bindings/Python/Generated/AST/OMPForDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPForDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPForDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPForDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPForDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPForDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPForSimdDirective.cpp
index d303b60d8..7aa2fd864 100644
--- a/bindings/Python/Generated/AST/OMPForSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPForSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPForSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPForSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPForSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPForSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPGenericLoopDirective.cpp
index 3744b4f6d..2b62003a2 100644
--- a/bindings/Python/Generated/AST/OMPGenericLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPGenericLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPGenericLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPGenericLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPGenericLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPGenericLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPInteropDirective.cpp b/bindings/Python/Generated/AST/OMPInteropDirective.cpp
index f45532183..282547288 100644
--- a/bindings/Python/Generated/AST/OMPInteropDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPInteropDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPInteropDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPInteropDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPInteropDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPInteropDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPIteratorExpr.cpp b/bindings/Python/Generated/AST/OMPIteratorExpr.cpp
index 58fad702d..76a1616f3 100644
--- a/bindings/Python/Generated/AST/OMPIteratorExpr.cpp
+++ b/bindings/Python/Generated/AST/OMPIteratorExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPIteratorExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPIteratorExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPIteratorExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPIteratorExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPLoopBasedDirective.cpp b/bindings/Python/Generated/AST/OMPLoopBasedDirective.cpp
index 7be0acd71..3443bd107 100644
--- a/bindings/Python/Generated/AST/OMPLoopBasedDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPLoopBasedDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -382,18 +381,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::OMPLoopBasedDirective::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPLoopBasedDirective::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPLoopBasedDirective::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -419,7 +456,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -442,52 +479,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPLoopBasedDirective::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPLoopBasedDirective::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPLoopBasedDirective::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPLoopDirective.cpp b/bindings/Python/Generated/AST/OMPLoopDirective.cpp
index 56fb1887f..5097617d7 100644
--- a/bindings/Python/Generated/AST/OMPLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -814,18 +813,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::OMPLoopDirective::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPLoopDirective::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPLoopDirective::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -851,7 +888,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -874,52 +911,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPLoopDirective::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPLoopDirective::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPLoopDirective::from_base"),
-  },
   {
     "nth_counter",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/OMPLoopTransformationDirective.cpp b/bindings/Python/Generated/AST/OMPLoopTransformationDirective.cpp
index b19d1cd13..f7704148f 100644
--- a/bindings/Python/Generated/AST/OMPLoopTransformationDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPLoopTransformationDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -252,18 +251,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::OMPLoopTransformationDirective::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPLoopTransformationDirective::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPLoopTransformationDirective::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -289,7 +326,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -312,52 +349,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPLoopTransformationDirective::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPLoopTransformationDirective::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPLoopTransformationDirective::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPMaskedDirective.cpp b/bindings/Python/Generated/AST/OMPMaskedDirective.cpp
index cdcdf0669..97dd5af19 100644
--- a/bindings/Python/Generated/AST/OMPMaskedDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPMaskedDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMaskedDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPMaskedDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMaskedDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPMaskedDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPMaskedTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPMaskedTaskLoopDirective.cpp
index 08a679af1..8714559ea 100644
--- a/bindings/Python/Generated/AST/OMPMaskedTaskLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPMaskedTaskLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMaskedTaskLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPMaskedTaskLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMaskedTaskLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPMaskedTaskLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPMaskedTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPMaskedTaskLoopSimdDirective.cpp
index 9ff4cc41f..f75304d3b 100644
--- a/bindings/Python/Generated/AST/OMPMaskedTaskLoopSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPMaskedTaskLoopSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMaskedTaskLoopSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPMaskedTaskLoopSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMaskedTaskLoopSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPMaskedTaskLoopSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPMasterDirective.cpp b/bindings/Python/Generated/AST/OMPMasterDirective.cpp
index 90cc66934..34aeda128 100644
--- a/bindings/Python/Generated/AST/OMPMasterDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPMasterDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMasterDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPMasterDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMasterDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPMasterDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPMasterTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPMasterTaskLoopDirective.cpp
index 08f9fb752..711c4b0d3 100644
--- a/bindings/Python/Generated/AST/OMPMasterTaskLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPMasterTaskLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMasterTaskLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPMasterTaskLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMasterTaskLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPMasterTaskLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPMasterTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPMasterTaskLoopSimdDirective.cpp
index 3764bde5d..43639947d 100644
--- a/bindings/Python/Generated/AST/OMPMasterTaskLoopSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPMasterTaskLoopSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMasterTaskLoopSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPMasterTaskLoopSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMasterTaskLoopSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPMasterTaskLoopSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPMetaDirective.cpp b/bindings/Python/Generated/AST/OMPMetaDirective.cpp
index 239440878..06bb864df 100644
--- a/bindings/Python/Generated/AST/OMPMetaDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPMetaDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMetaDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPMetaDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPMetaDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPMetaDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPOrderedDirective.cpp b/bindings/Python/Generated/AST/OMPOrderedDirective.cpp
index fd844f538..112ff1566 100644
--- a/bindings/Python/Generated/AST/OMPOrderedDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPOrderedDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPOrderedDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPOrderedDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPOrderedDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPOrderedDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelDirective.cpp b/bindings/Python/Generated/AST/OMPParallelDirective.cpp
index 758c71ebe..b4556ca5d 100644
--- a/bindings/Python/Generated/AST/OMPParallelDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPParallelForDirective.cpp
index 8d05243ff..889121059 100644
--- a/bindings/Python/Generated/AST/OMPParallelForDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelForDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelForDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelForDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelForDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelForDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPParallelForSimdDirective.cpp
index 1a7241fcc..05c854c53 100644
--- a/bindings/Python/Generated/AST/OMPParallelForSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelForSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelForSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelForSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelForSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelForSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPParallelGenericLoopDirective.cpp
index 63760af71..daa9f0a77 100644
--- a/bindings/Python/Generated/AST/OMPParallelGenericLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelGenericLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelGenericLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelGenericLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelGenericLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelGenericLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelMaskedDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMaskedDirective.cpp
index e4b4ce6b3..fe1bb7b2f 100644
--- a/bindings/Python/Generated/AST/OMPParallelMaskedDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelMaskedDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMaskedDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelMaskedDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMaskedDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelMaskedDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopDirective.cpp
index 3456aa4db..a7445d607 100644
--- a/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMaskedTaskLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelMaskedTaskLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMaskedTaskLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelMaskedTaskLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp
index 74f442ea8..fd3948286 100644
--- a/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMaskedTaskLoopSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelMaskedTaskLoopSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMaskedTaskLoopSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelMaskedTaskLoopSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelMasterDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMasterDirective.cpp
index 0f377333a..9e92a4512 100644
--- a/bindings/Python/Generated/AST/OMPParallelMasterDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelMasterDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMasterDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelMasterDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMasterDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelMasterDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopDirective.cpp
index f9690495b..d872c5893 100644
--- a/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMasterTaskLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelMasterTaskLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMasterTaskLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelMasterTaskLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopSimdDirective.cpp
index 0ec2319a0..2c8e26386 100644
--- a/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelMasterTaskLoopSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMasterTaskLoopSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelMasterTaskLoopSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelMasterTaskLoopSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelMasterTaskLoopSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPParallelSectionsDirective.cpp b/bindings/Python/Generated/AST/OMPParallelSectionsDirective.cpp
index 48500ce99..9a88e5982 100644
--- a/bindings/Python/Generated/AST/OMPParallelSectionsDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPParallelSectionsDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelSectionsDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPParallelSectionsDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPParallelSectionsDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPParallelSectionsDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPReferencedVarAttr.cpp b/bindings/Python/Generated/AST/OMPReferencedVarAttr.cpp
index 62aecddf7..9f120d8f4 100644
--- a/bindings/Python/Generated/AST/OMPReferencedVarAttr.cpp
+++ b/bindings/Python/Generated/AST/OMPReferencedVarAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OMPRequiresDecl.cpp b/bindings/Python/Generated/AST/OMPRequiresDecl.cpp
index e35726dc1..fa22abf0f 100644
--- a/bindings/Python/Generated/AST/OMPRequiresDecl.cpp
+++ b/bindings/Python/Generated/AST/OMPRequiresDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPRequiresDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPRequiresDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPRequiresDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPRequiresDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPScanDirective.cpp b/bindings/Python/Generated/AST/OMPScanDirective.cpp
index f0b778a39..bfef5f579 100644
--- a/bindings/Python/Generated/AST/OMPScanDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPScanDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPScanDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPScanDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPScanDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPScanDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPScopeDirective.cpp b/bindings/Python/Generated/AST/OMPScopeDirective.cpp
index 24938474e..d331a9339 100644
--- a/bindings/Python/Generated/AST/OMPScopeDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPScopeDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPScopeDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPScopeDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPScopeDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPScopeDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPSectionDirective.cpp b/bindings/Python/Generated/AST/OMPSectionDirective.cpp
index 61bd5e59f..15b0f0e6c 100644
--- a/bindings/Python/Generated/AST/OMPSectionDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPSectionDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPSectionDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPSectionDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPSectionDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPSectionDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPSectionsDirective.cpp b/bindings/Python/Generated/AST/OMPSectionsDirective.cpp
index 321a53040..d85004f11 100644
--- a/bindings/Python/Generated/AST/OMPSectionsDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPSectionsDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPSectionsDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPSectionsDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPSectionsDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPSectionsDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPSimdDirective.cpp b/bindings/Python/Generated/AST/OMPSimdDirective.cpp
index c548ca6dd..52a2a21cc 100644
--- a/bindings/Python/Generated/AST/OMPSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPSingleDirective.cpp b/bindings/Python/Generated/AST/OMPSingleDirective.cpp
index cf47642c7..c1daccfa7 100644
--- a/bindings/Python/Generated/AST/OMPSingleDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPSingleDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPSingleDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPSingleDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPSingleDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPSingleDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetDataDirective.cpp b/bindings/Python/Generated/AST/OMPTargetDataDirective.cpp
index e410d02d5..70ed5b2fb 100644
--- a/bindings/Python/Generated/AST/OMPTargetDataDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetDataDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetDataDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetDataDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetDataDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetDataDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetDirective.cpp b/bindings/Python/Generated/AST/OMPTargetDirective.cpp
index 2ab3f9fb8..0972659f9 100644
--- a/bindings/Python/Generated/AST/OMPTargetDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetEnterDataDirective.cpp b/bindings/Python/Generated/AST/OMPTargetEnterDataDirective.cpp
index 91e43bed9..43757596e 100644
--- a/bindings/Python/Generated/AST/OMPTargetEnterDataDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetEnterDataDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetEnterDataDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetEnterDataDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetEnterDataDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetEnterDataDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetExitDataDirective.cpp b/bindings/Python/Generated/AST/OMPTargetExitDataDirective.cpp
index b6924a51a..9eea16662 100644
--- a/bindings/Python/Generated/AST/OMPTargetExitDataDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetExitDataDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetExitDataDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetExitDataDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetExitDataDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetExitDataDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetParallelDirective.cpp b/bindings/Python/Generated/AST/OMPTargetParallelDirective.cpp
index f72e0da38..6744da2f1 100644
--- a/bindings/Python/Generated/AST/OMPTargetParallelDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetParallelDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetParallelDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetParallelDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetParallelDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetParallelDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPTargetParallelForDirective.cpp
index 78983a4e0..110a7cca9 100644
--- a/bindings/Python/Generated/AST/OMPTargetParallelForDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetParallelForDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetParallelForDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetParallelForDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetParallelForDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetParallelForDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTargetParallelForSimdDirective.cpp
index 2d940ee20..c4c8b923a 100644
--- a/bindings/Python/Generated/AST/OMPTargetParallelForSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetParallelForSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetParallelForSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetParallelForSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetParallelForSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetParallelForSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetParallelGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPTargetParallelGenericLoopDirective.cpp
index 43285569f..fbf9e1575 100644
--- a/bindings/Python/Generated/AST/OMPTargetParallelGenericLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetParallelGenericLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetParallelGenericLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetParallelGenericLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetParallelGenericLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetParallelGenericLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTargetSimdDirective.cpp
index 7eb293dc3..bcb7eb7a3 100644
--- a/bindings/Python/Generated/AST/OMPTargetSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDirective.cpp
index 3713cf23c..7d8685d49 100644
--- a/bindings/Python/Generated/AST/OMPTargetTeamsDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetTeamsDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeDirective.cpp
index dfd4e8a36..4ce1e7f3c 100644
--- a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForDirective.cpp
index 2272b95cd..72ccdfa40 100644
--- a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeParallelForDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeParallelForDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeParallelForDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeParallelForDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp
index b6bb4a93b..69cbc9f46 100644
--- a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeParallelForSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeParallelForSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeParallelForSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeParallelForSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeSimdDirective.cpp
index 3654e3fe1..05ff2084f 100644
--- a/bindings/Python/Generated/AST/OMPTargetTeamsDistributeSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetTeamsDistributeSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetTeamsDistributeSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetTeamsGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPTargetTeamsGenericLoopDirective.cpp
index a6a7fb6bb..e5417f3da 100644
--- a/bindings/Python/Generated/AST/OMPTargetTeamsGenericLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetTeamsGenericLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsGenericLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetTeamsGenericLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetTeamsGenericLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetTeamsGenericLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTargetUpdateDirective.cpp b/bindings/Python/Generated/AST/OMPTargetUpdateDirective.cpp
index 0766e3ec9..54edf66d4 100644
--- a/bindings/Python/Generated/AST/OMPTargetUpdateDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTargetUpdateDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetUpdateDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTargetUpdateDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTargetUpdateDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTargetUpdateDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTaskDirective.cpp b/bindings/Python/Generated/AST/OMPTaskDirective.cpp
index 9289b0c8b..4056da67b 100644
--- a/bindings/Python/Generated/AST/OMPTaskDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTaskDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTaskDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTaskDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTaskLoopDirective.cpp b/bindings/Python/Generated/AST/OMPTaskLoopDirective.cpp
index 4a4f16920..92e0372f1 100644
--- a/bindings/Python/Generated/AST/OMPTaskLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTaskLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTaskLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTaskLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTaskLoopSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTaskLoopSimdDirective.cpp
index b78db9e4f..ef47f2d93 100644
--- a/bindings/Python/Generated/AST/OMPTaskLoopSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTaskLoopSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskLoopSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTaskLoopSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskLoopSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTaskLoopSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTaskgroupDirective.cpp b/bindings/Python/Generated/AST/OMPTaskgroupDirective.cpp
index 8645f00c2..e92bf4913 100644
--- a/bindings/Python/Generated/AST/OMPTaskgroupDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTaskgroupDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskgroupDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTaskgroupDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskgroupDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTaskgroupDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTaskwaitDirective.cpp b/bindings/Python/Generated/AST/OMPTaskwaitDirective.cpp
index bf560295b..ad4e85203 100644
--- a/bindings/Python/Generated/AST/OMPTaskwaitDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTaskwaitDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskwaitDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTaskwaitDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskwaitDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTaskwaitDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTaskyieldDirective.cpp b/bindings/Python/Generated/AST/OMPTaskyieldDirective.cpp
index 6db3907b4..fed0cab2d 100644
--- a/bindings/Python/Generated/AST/OMPTaskyieldDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTaskyieldDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskyieldDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTaskyieldDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTaskyieldDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTaskyieldDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTeamsDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDirective.cpp
index 8511b843a..9bcca88f6 100644
--- a/bindings/Python/Generated/AST/OMPTeamsDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTeamsDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTeamsDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTeamsDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTeamsDistributeDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDistributeDirective.cpp
index 3146dde7e..7f9df622f 100644
--- a/bindings/Python/Generated/AST/OMPTeamsDistributeDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTeamsDistributeDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDistributeDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTeamsDistributeDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDistributeDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTeamsDistributeDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForDirective.cpp
index b30234f8b..47065e1c6 100644
--- a/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDistributeParallelForDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTeamsDistributeParallelForDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDistributeParallelForDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTeamsDistributeParallelForDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForSimdDirective.cpp
index ec8b130b8..1d1d8a0d7 100644
--- a/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTeamsDistributeParallelForSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDistributeParallelForSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTeamsDistributeParallelForSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDistributeParallelForSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTeamsDistributeParallelForSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTeamsDistributeSimdDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsDistributeSimdDirective.cpp
index 895abb178..dd75d8fba 100644
--- a/bindings/Python/Generated/AST/OMPTeamsDistributeSimdDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTeamsDistributeSimdDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDistributeSimdDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTeamsDistributeSimdDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsDistributeSimdDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTeamsDistributeSimdDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPTeamsGenericLoopDirective.cpp b/bindings/Python/Generated/AST/OMPTeamsGenericLoopDirective.cpp
index ccfc99dc3..80716534e 100644
--- a/bindings/Python/Generated/AST/OMPTeamsGenericLoopDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTeamsGenericLoopDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsGenericLoopDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTeamsGenericLoopDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTeamsGenericLoopDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTeamsGenericLoopDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPThreadPrivateDecl.cpp b/bindings/Python/Generated/AST/OMPThreadPrivateDecl.cpp
index 0d826171b..d8062c522 100644
--- a/bindings/Python/Generated/AST/OMPThreadPrivateDecl.cpp
+++ b/bindings/Python/Generated/AST/OMPThreadPrivateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPThreadPrivateDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPThreadPrivateDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPThreadPrivateDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPThreadPrivateDecl::from"),
+  },
   {
     "nth_varlist",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/OMPThreadPrivateDeclAttr.cpp b/bindings/Python/Generated/AST/OMPThreadPrivateDeclAttr.cpp
index 989042fe1..e56a80f7c 100644
--- a/bindings/Python/Generated/AST/OMPThreadPrivateDeclAttr.cpp
+++ b/bindings/Python/Generated/AST/OMPThreadPrivateDeclAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OMPTileDirective.cpp b/bindings/Python/Generated/AST/OMPTileDirective.cpp
index cb8790381..7c0f3e920 100644
--- a/bindings/Python/Generated/AST/OMPTileDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPTileDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTileDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPTileDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPTileDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPTileDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OMPUnrollDirective.cpp b/bindings/Python/Generated/AST/OMPUnrollDirective.cpp
index b26b54dbf..dbb6c0652 100644
--- a/bindings/Python/Generated/AST/OMPUnrollDirective.cpp
+++ b/bindings/Python/Generated/AST/OMPUnrollDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPUnrollDirective::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OMPUnrollDirective::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OMPUnrollDirective::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OMPUnrollDirective::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OSConsumedAttr.cpp b/bindings/Python/Generated/AST/OSConsumedAttr.cpp
index 6008c886a..b720b503d 100644
--- a/bindings/Python/Generated/AST/OSConsumedAttr.cpp
+++ b/bindings/Python/Generated/AST/OSConsumedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OSConsumesThisAttr.cpp b/bindings/Python/Generated/AST/OSConsumesThisAttr.cpp
index f29157d0e..53dd76f6a 100644
--- a/bindings/Python/Generated/AST/OSConsumesThisAttr.cpp
+++ b/bindings/Python/Generated/AST/OSConsumesThisAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OSReturnsNotRetainedAttr.cpp b/bindings/Python/Generated/AST/OSReturnsNotRetainedAttr.cpp
index 5afb75c35..22715cc93 100644
--- a/bindings/Python/Generated/AST/OSReturnsNotRetainedAttr.cpp
+++ b/bindings/Python/Generated/AST/OSReturnsNotRetainedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OSReturnsRetainedAttr.cpp b/bindings/Python/Generated/AST/OSReturnsRetainedAttr.cpp
index 4c3b6ed98..1cfb9e6fa 100644
--- a/bindings/Python/Generated/AST/OSReturnsRetainedAttr.cpp
+++ b/bindings/Python/Generated/AST/OSReturnsRetainedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OSReturnsRetainedOnNonZeroAttr.cpp b/bindings/Python/Generated/AST/OSReturnsRetainedOnNonZeroAttr.cpp
index 1a2ba3037..627818cb8 100644
--- a/bindings/Python/Generated/AST/OSReturnsRetainedOnNonZeroAttr.cpp
+++ b/bindings/Python/Generated/AST/OSReturnsRetainedOnNonZeroAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OSReturnsRetainedOnZeroAttr.cpp b/bindings/Python/Generated/AST/OSReturnsRetainedOnZeroAttr.cpp
index 25a458642..3cfa9eef3 100644
--- a/bindings/Python/Generated/AST/OSReturnsRetainedOnZeroAttr.cpp
+++ b/bindings/Python/Generated/AST/OSReturnsRetainedOnZeroAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCArrayLiteral.cpp b/bindings/Python/Generated/AST/ObjCArrayLiteral.cpp
index 400292267..6d7d20ecd 100644
--- a/bindings/Python/Generated/AST/ObjCArrayLiteral.cpp
+++ b/bindings/Python/Generated/AST/ObjCArrayLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCArrayLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCArrayLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCArrayLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCArrayLiteral::from"),
+  },
   {
     "nth_element",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCAtCatchStmt.cpp b/bindings/Python/Generated/AST/ObjCAtCatchStmt.cpp
index 4247e8334..b77e6ce04 100644
--- a/bindings/Python/Generated/AST/ObjCAtCatchStmt.cpp
+++ b/bindings/Python/Generated/AST/ObjCAtCatchStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtCatchStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCAtCatchStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtCatchStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCAtCatchStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCAtDefsFieldDecl.cpp b/bindings/Python/Generated/AST/ObjCAtDefsFieldDecl.cpp
index 9011e7f73..a90d63a64 100644
--- a/bindings/Python/Generated/AST/ObjCAtDefsFieldDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCAtDefsFieldDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtDefsFieldDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCAtDefsFieldDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtDefsFieldDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCAtDefsFieldDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCAtFinallyStmt.cpp b/bindings/Python/Generated/AST/ObjCAtFinallyStmt.cpp
index 719d63c8d..ae33a149d 100644
--- a/bindings/Python/Generated/AST/ObjCAtFinallyStmt.cpp
+++ b/bindings/Python/Generated/AST/ObjCAtFinallyStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtFinallyStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCAtFinallyStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtFinallyStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCAtFinallyStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCAtSynchronizedStmt.cpp b/bindings/Python/Generated/AST/ObjCAtSynchronizedStmt.cpp
index 05364642d..ace1ac21f 100644
--- a/bindings/Python/Generated/AST/ObjCAtSynchronizedStmt.cpp
+++ b/bindings/Python/Generated/AST/ObjCAtSynchronizedStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtSynchronizedStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCAtSynchronizedStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtSynchronizedStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCAtSynchronizedStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCAtThrowStmt.cpp b/bindings/Python/Generated/AST/ObjCAtThrowStmt.cpp
index 4b50ec917..50ed661c6 100644
--- a/bindings/Python/Generated/AST/ObjCAtThrowStmt.cpp
+++ b/bindings/Python/Generated/AST/ObjCAtThrowStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtThrowStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCAtThrowStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtThrowStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCAtThrowStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCAtTryStmt.cpp b/bindings/Python/Generated/AST/ObjCAtTryStmt.cpp
index 06a09f1c6..ac2be34a6 100644
--- a/bindings/Python/Generated/AST/ObjCAtTryStmt.cpp
+++ b/bindings/Python/Generated/AST/ObjCAtTryStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtTryStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCAtTryStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAtTryStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCAtTryStmt::from"),
+  },
   {
     "nth_catch_statement",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCAutoreleasePoolStmt.cpp b/bindings/Python/Generated/AST/ObjCAutoreleasePoolStmt.cpp
index 6c18718e5..2fae5f958 100644
--- a/bindings/Python/Generated/AST/ObjCAutoreleasePoolStmt.cpp
+++ b/bindings/Python/Generated/AST/ObjCAutoreleasePoolStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAutoreleasePoolStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCAutoreleasePoolStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAutoreleasePoolStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCAutoreleasePoolStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCAvailabilityCheckExpr.cpp b/bindings/Python/Generated/AST/ObjCAvailabilityCheckExpr.cpp
index 5c10b2f24..774cd8ae4 100644
--- a/bindings/Python/Generated/AST/ObjCAvailabilityCheckExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCAvailabilityCheckExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAvailabilityCheckExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCAvailabilityCheckExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCAvailabilityCheckExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCAvailabilityCheckExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCBoolLiteralExpr.cpp b/bindings/Python/Generated/AST/ObjCBoolLiteralExpr.cpp
index e82937e4d..b7e028d8b 100644
--- a/bindings/Python/Generated/AST/ObjCBoolLiteralExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCBoolLiteralExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCBoolLiteralExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCBoolLiteralExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCBoolLiteralExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCBoolLiteralExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCBoxableAttr.cpp b/bindings/Python/Generated/AST/ObjCBoxableAttr.cpp
index bfbb991c4..597b0f379 100644
--- a/bindings/Python/Generated/AST/ObjCBoxableAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCBoxableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCBoxedExpr.cpp b/bindings/Python/Generated/AST/ObjCBoxedExpr.cpp
index 34d7f3e86..9f443aca1 100644
--- a/bindings/Python/Generated/AST/ObjCBoxedExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCBoxedExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCBoxedExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCBoxedExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCBoxedExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCBoxedExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCBridgeAttr.cpp b/bindings/Python/Generated/AST/ObjCBridgeAttr.cpp
index 935d9a6d1..3f35a1b0e 100644
--- a/bindings/Python/Generated/AST/ObjCBridgeAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCBridgeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCBridgeMutableAttr.cpp b/bindings/Python/Generated/AST/ObjCBridgeMutableAttr.cpp
index 0d3083d8c..9b72fa6cf 100644
--- a/bindings/Python/Generated/AST/ObjCBridgeMutableAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCBridgeMutableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCBridgeRelatedAttr.cpp b/bindings/Python/Generated/AST/ObjCBridgeRelatedAttr.cpp
index e67864dc3..75e99cec7 100644
--- a/bindings/Python/Generated/AST/ObjCBridgeRelatedAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCBridgeRelatedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCBridgedCastExpr.cpp b/bindings/Python/Generated/AST/ObjCBridgedCastExpr.cpp
index 7afc0eeee..0e124190f 100644
--- a/bindings/Python/Generated/AST/ObjCBridgedCastExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCBridgedCastExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCBridgedCastExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCBridgedCastExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCBridgedCastExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCBridgedCastExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCCategoryDecl.cpp b/bindings/Python/Generated/AST/ObjCCategoryDecl.cpp
index 696cc25ee..1efa33401 100644
--- a/bindings/Python/Generated/AST/ObjCCategoryDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCCategoryDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -387,67 +386,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCCategoryDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCCategoryDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -511,6 +449,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCCategoryDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCCategoryDecl::from"),
+  },
   {
     "nth_instance_variable",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCCategoryImplDecl.cpp b/bindings/Python/Generated/AST/ObjCCategoryImplDecl.cpp
index 4c51c7ae0..8349d47c5 100644
--- a/bindings/Python/Generated/AST/ObjCCategoryImplDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCCategoryImplDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCCategoryImplDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCCategoryImplDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCCategoryImplDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCCategoryImplDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCClassStubAttr.cpp b/bindings/Python/Generated/AST/ObjCClassStubAttr.cpp
index da140de8d..9f9ecca88 100644
--- a/bindings/Python/Generated/AST/ObjCClassStubAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCClassStubAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCCompatibleAliasDecl.cpp b/bindings/Python/Generated/AST/ObjCCompatibleAliasDecl.cpp
index 5b90e6882..d0c9ca939 100644
--- a/bindings/Python/Generated/AST/ObjCCompatibleAliasDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCCompatibleAliasDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCCompatibleAliasDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCCompatibleAliasDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCCompatibleAliasDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCCompatibleAliasDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCContainerDecl.cpp b/bindings/Python/Generated/AST/ObjCContainerDecl.cpp
index 306e075a7..52f0a9ec8 100644
--- a/bindings/Python/Generated/AST/ObjCContainerDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCContainerDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -424,18 +423,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::ObjCContainerDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCContainerDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCContainerDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -461,7 +498,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -484,52 +521,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCContainerDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCContainerDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCContainerDecl::from_base"),
-  },
   {
     "nth_class_method",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCDesignatedInitializerAttr.cpp b/bindings/Python/Generated/AST/ObjCDesignatedInitializerAttr.cpp
index f76207d46..a59cd5120 100644
--- a/bindings/Python/Generated/AST/ObjCDesignatedInitializerAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCDesignatedInitializerAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCDictionaryLiteral.cpp b/bindings/Python/Generated/AST/ObjCDictionaryLiteral.cpp
index 2ca35fe37..9ec122d2c 100644
--- a/bindings/Python/Generated/AST/ObjCDictionaryLiteral.cpp
+++ b/bindings/Python/Generated/AST/ObjCDictionaryLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCDictionaryLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCDictionaryLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCDictionaryLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCDictionaryLiteral::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCDirectAttr.cpp b/bindings/Python/Generated/AST/ObjCDirectAttr.cpp
index c96b5d43e..23b1c0ea1 100644
--- a/bindings/Python/Generated/AST/ObjCDirectAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCDirectAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCDirectMembersAttr.cpp b/bindings/Python/Generated/AST/ObjCDirectMembersAttr.cpp
index bb246576c..d3b396f99 100644
--- a/bindings/Python/Generated/AST/ObjCDirectMembersAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCDirectMembersAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCEncodeExpr.cpp b/bindings/Python/Generated/AST/ObjCEncodeExpr.cpp
index 6de795d1d..a45becb8c 100644
--- a/bindings/Python/Generated/AST/ObjCEncodeExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCEncodeExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCEncodeExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCEncodeExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCEncodeExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCEncodeExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCExceptionAttr.cpp b/bindings/Python/Generated/AST/ObjCExceptionAttr.cpp
index c2475c7b6..ed2f36ea6 100644
--- a/bindings/Python/Generated/AST/ObjCExceptionAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCExceptionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCExplicitProtocolImplAttr.cpp b/bindings/Python/Generated/AST/ObjCExplicitProtocolImplAttr.cpp
index 912e14405..4345d50dc 100644
--- a/bindings/Python/Generated/AST/ObjCExplicitProtocolImplAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCExplicitProtocolImplAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCExternallyRetainedAttr.cpp b/bindings/Python/Generated/AST/ObjCExternallyRetainedAttr.cpp
index 56fd64f97..0ee50296a 100644
--- a/bindings/Python/Generated/AST/ObjCExternallyRetainedAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCExternallyRetainedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCForCollectionStmt.cpp b/bindings/Python/Generated/AST/ObjCForCollectionStmt.cpp
index ca072e399..07c5ab240 100644
--- a/bindings/Python/Generated/AST/ObjCForCollectionStmt.cpp
+++ b/bindings/Python/Generated/AST/ObjCForCollectionStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCForCollectionStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCForCollectionStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCForCollectionStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCForCollectionStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCGCAttr.cpp b/bindings/Python/Generated/AST/ObjCGCAttr.cpp
index 64c1b7bda..7b8bf9773 100644
--- a/bindings/Python/Generated/AST/ObjCGCAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCGCAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCImplDecl.cpp b/bindings/Python/Generated/AST/ObjCImplDecl.cpp
index fcfda1b2e..a45605ad4 100644
--- a/bindings/Python/Generated/AST/ObjCImplDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCImplDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -292,18 +291,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::ObjCImplDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCImplDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCImplDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -329,7 +366,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -352,52 +389,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCImplDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCImplDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCImplDecl::from_base"),
-  },
   {
     "nth_property_implementation",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCImplementationDecl.cpp b/bindings/Python/Generated/AST/ObjCImplementationDecl.cpp
index 0cb204c87..3cd5cc46e 100644
--- a/bindings/Python/Generated/AST/ObjCImplementationDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCImplementationDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -367,67 +366,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCImplementationDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCImplementationDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -491,6 +429,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCImplementationDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCImplementationDecl::from"),
+  },
   {
     "nth_initializer",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCIndependentClassAttr.cpp b/bindings/Python/Generated/AST/ObjCIndependentClassAttr.cpp
index 498e4165f..ad27f364f 100644
--- a/bindings/Python/Generated/AST/ObjCIndependentClassAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCIndependentClassAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCIndirectCopyRestoreExpr.cpp b/bindings/Python/Generated/AST/ObjCIndirectCopyRestoreExpr.cpp
index f6dcc3d7e..829c11fec 100644
--- a/bindings/Python/Generated/AST/ObjCIndirectCopyRestoreExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCIndirectCopyRestoreExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCIndirectCopyRestoreExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCIndirectCopyRestoreExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCIndirectCopyRestoreExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCIndirectCopyRestoreExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCInertUnsafeUnretainedAttr.cpp b/bindings/Python/Generated/AST/ObjCInertUnsafeUnretainedAttr.cpp
index fd2d1e712..95aaf2a09 100644
--- a/bindings/Python/Generated/AST/ObjCInertUnsafeUnretainedAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCInertUnsafeUnretainedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCInterfaceDecl.cpp b/bindings/Python/Generated/AST/ObjCInterfaceDecl.cpp
index cd55aeb25..53fae5787 100644
--- a/bindings/Python/Generated/AST/ObjCInterfaceDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCInterfaceDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -557,67 +556,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCInterfaceDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCInterfaceDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -681,6 +619,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCInterfaceDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCInterfaceDecl::from"),
+  },
   {
     "nth_all_referenced_protocol",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCInterfaceType.cpp b/bindings/Python/Generated/AST/ObjCInterfaceType.cpp
index 4abc8a831..4f41bfce8 100644
--- a/bindings/Python/Generated/AST/ObjCInterfaceType.cpp
+++ b/bindings/Python/Generated/AST/ObjCInterfaceType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -274,7 +273,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCIsaExpr.cpp b/bindings/Python/Generated/AST/ObjCIsaExpr.cpp
index ea3e76908..e28e7688d 100644
--- a/bindings/Python/Generated/AST/ObjCIsaExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCIsaExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCIsaExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCIsaExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCIsaExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCIsaExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCIvarDecl.cpp b/bindings/Python/Generated/AST/ObjCIvarDecl.cpp
index f84905c62..734891aa4 100644
--- a/bindings/Python/Generated/AST/ObjCIvarDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCIvarDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCIvarDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCIvarDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCIvarDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCIvarDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCIvarRefExpr.cpp b/bindings/Python/Generated/AST/ObjCIvarRefExpr.cpp
index 5b788b5d5..61a1b34e1 100644
--- a/bindings/Python/Generated/AST/ObjCIvarRefExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCIvarRefExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCIvarRefExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCIvarRefExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCIvarRefExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCIvarRefExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCKindOfAttr.cpp b/bindings/Python/Generated/AST/ObjCKindOfAttr.cpp
index 886f2ca2b..8f8827c19 100644
--- a/bindings/Python/Generated/AST/ObjCKindOfAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCKindOfAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCMessageExpr.cpp b/bindings/Python/Generated/AST/ObjCMessageExpr.cpp
index f9d7ccc52..492222851 100644
--- a/bindings/Python/Generated/AST/ObjCMessageExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCMessageExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -447,67 +446,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCMessageExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCMessageExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -571,6 +509,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCMessageExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCMessageExpr::from"),
+  },
   {
     "nth_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCMethodDecl.cpp b/bindings/Python/Generated/AST/ObjCMethodDecl.cpp
index 1a62b51f0..62c145b60 100644
--- a/bindings/Python/Generated/AST/ObjCMethodDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCMethodDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -597,67 +596,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCMethodDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCMethodDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -721,6 +659,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCMethodDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCMethodDecl::from"),
+  },
   {
     "nth_parameter",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCMethodFamilyAttr.cpp b/bindings/Python/Generated/AST/ObjCMethodFamilyAttr.cpp
index c988a692a..4f1b5c883 100644
--- a/bindings/Python/Generated/AST/ObjCMethodFamilyAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCMethodFamilyAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCNSObjectAttr.cpp b/bindings/Python/Generated/AST/ObjCNSObjectAttr.cpp
index a6f05e69f..9a5ec87e0 100644
--- a/bindings/Python/Generated/AST/ObjCNSObjectAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCNSObjectAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCNonLazyClassAttr.cpp b/bindings/Python/Generated/AST/ObjCNonLazyClassAttr.cpp
index 7c3208239..e8917a279 100644
--- a/bindings/Python/Generated/AST/ObjCNonLazyClassAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCNonLazyClassAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCNonRuntimeProtocolAttr.cpp b/bindings/Python/Generated/AST/ObjCNonRuntimeProtocolAttr.cpp
index 0a56e9094..eade4a768 100644
--- a/bindings/Python/Generated/AST/ObjCNonRuntimeProtocolAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCNonRuntimeProtocolAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCObjectPointerType.cpp b/bindings/Python/Generated/AST/ObjCObjectPointerType.cpp
index a8f8fa14d..6e39a7d31 100644
--- a/bindings/Python/Generated/AST/ObjCObjectPointerType.cpp
+++ b/bindings/Python/Generated/AST/ObjCObjectPointerType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -464,7 +463,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCObjectType.cpp b/bindings/Python/Generated/AST/ObjCObjectType.cpp
index cfd06d906..ff71b31b8 100644
--- a/bindings/Python/Generated/AST/ObjCObjectType.cpp
+++ b/bindings/Python/Generated/AST/ObjCObjectType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -478,7 +477,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCOwnershipAttr.cpp b/bindings/Python/Generated/AST/ObjCOwnershipAttr.cpp
index 2e46236d8..0cbffe301 100644
--- a/bindings/Python/Generated/AST/ObjCOwnershipAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCOwnershipAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCPreciseLifetimeAttr.cpp b/bindings/Python/Generated/AST/ObjCPreciseLifetimeAttr.cpp
index dfc35ee11..51d714924 100644
--- a/bindings/Python/Generated/AST/ObjCPreciseLifetimeAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCPreciseLifetimeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCPropertyDecl.cpp b/bindings/Python/Generated/AST/ObjCPropertyDecl.cpp
index 97515750f..5bc2cab89 100644
--- a/bindings/Python/Generated/AST/ObjCPropertyDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCPropertyDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -437,67 +436,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCPropertyDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCPropertyDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -561,6 +499,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCPropertyDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCPropertyDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCPropertyImplDecl.cpp b/bindings/Python/Generated/AST/ObjCPropertyImplDecl.cpp
index b650102ff..ee9c72689 100644
--- a/bindings/Python/Generated/AST/ObjCPropertyImplDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCPropertyImplDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -347,67 +346,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCPropertyImplDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCPropertyImplDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -471,6 +409,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCPropertyImplDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCPropertyImplDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCPropertyRefExpr.cpp b/bindings/Python/Generated/AST/ObjCPropertyRefExpr.cpp
index a457f5e02..46bf0da44 100644
--- a/bindings/Python/Generated/AST/ObjCPropertyRefExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCPropertyRefExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -387,67 +386,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCPropertyRefExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCPropertyRefExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -511,6 +449,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCPropertyRefExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCPropertyRefExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCProtocolDecl.cpp b/bindings/Python/Generated/AST/ObjCProtocolDecl.cpp
index 007f57440..75a4a77b3 100644
--- a/bindings/Python/Generated/AST/ObjCProtocolDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCProtocolDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -337,67 +336,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCProtocolDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCProtocolDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -461,6 +399,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCProtocolDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCProtocolDecl::from"),
+  },
   {
     "nth_protocol_token",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ObjCProtocolExpr.cpp b/bindings/Python/Generated/AST/ObjCProtocolExpr.cpp
index 62fd35dc0..a7e5d6aed 100644
--- a/bindings/Python/Generated/AST/ObjCProtocolExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCProtocolExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCProtocolExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCProtocolExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCProtocolExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCProtocolExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCRequiresPropertyDefsAttr.cpp b/bindings/Python/Generated/AST/ObjCRequiresPropertyDefsAttr.cpp
index 38389162f..b42d87e3d 100644
--- a/bindings/Python/Generated/AST/ObjCRequiresPropertyDefsAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCRequiresPropertyDefsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCRequiresSuperAttr.cpp b/bindings/Python/Generated/AST/ObjCRequiresSuperAttr.cpp
index 234cc5fcf..3cbd0ba7f 100644
--- a/bindings/Python/Generated/AST/ObjCRequiresSuperAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCRequiresSuperAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCReturnsInnerPointerAttr.cpp b/bindings/Python/Generated/AST/ObjCReturnsInnerPointerAttr.cpp
index 87afd7d93..8b54a1e1f 100644
--- a/bindings/Python/Generated/AST/ObjCReturnsInnerPointerAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCReturnsInnerPointerAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCRootClassAttr.cpp b/bindings/Python/Generated/AST/ObjCRootClassAttr.cpp
index f022cf146..9dd775dc0 100644
--- a/bindings/Python/Generated/AST/ObjCRootClassAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCRootClassAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCRuntimeNameAttr.cpp b/bindings/Python/Generated/AST/ObjCRuntimeNameAttr.cpp
index fb5cb1bbf..11b54943b 100644
--- a/bindings/Python/Generated/AST/ObjCRuntimeNameAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCRuntimeNameAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCRuntimeVisibleAttr.cpp b/bindings/Python/Generated/AST/ObjCRuntimeVisibleAttr.cpp
index daf3acbff..85c34130f 100644
--- a/bindings/Python/Generated/AST/ObjCRuntimeVisibleAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCRuntimeVisibleAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCSelectorExpr.cpp b/bindings/Python/Generated/AST/ObjCSelectorExpr.cpp
index 67f681d7a..8ec97ea60 100644
--- a/bindings/Python/Generated/AST/ObjCSelectorExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCSelectorExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCSelectorExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCSelectorExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCSelectorExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCSelectorExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCStringLiteral.cpp b/bindings/Python/Generated/AST/ObjCStringLiteral.cpp
index da1300365..f9b3babd1 100644
--- a/bindings/Python/Generated/AST/ObjCStringLiteral.cpp
+++ b/bindings/Python/Generated/AST/ObjCStringLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCStringLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCStringLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCStringLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCStringLiteral::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCSubclassingRestrictedAttr.cpp b/bindings/Python/Generated/AST/ObjCSubclassingRestrictedAttr.cpp
index 2f5f0b5c5..131acd295 100644
--- a/bindings/Python/Generated/AST/ObjCSubclassingRestrictedAttr.cpp
+++ b/bindings/Python/Generated/AST/ObjCSubclassingRestrictedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ObjCSubscriptRefExpr.cpp b/bindings/Python/Generated/AST/ObjCSubscriptRefExpr.cpp
index 724d2164f..056038275 100644
--- a/bindings/Python/Generated/AST/ObjCSubscriptRefExpr.cpp
+++ b/bindings/Python/Generated/AST/ObjCSubscriptRefExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCSubscriptRefExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCSubscriptRefExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCSubscriptRefExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCSubscriptRefExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCTypeParamDecl.cpp b/bindings/Python/Generated/AST/ObjCTypeParamDecl.cpp
index e589f6dc2..bc6fd2dcd 100644
--- a/bindings/Python/Generated/AST/ObjCTypeParamDecl.cpp
+++ b/bindings/Python/Generated/AST/ObjCTypeParamDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCTypeParamDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ObjCTypeParamDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ObjCTypeParamDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ObjCTypeParamDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ObjCTypeParamType.cpp b/bindings/Python/Generated/AST/ObjCTypeParamType.cpp
index a772befa1..63c090d49 100644
--- a/bindings/Python/Generated/AST/ObjCTypeParamType.cpp
+++ b/bindings/Python/Generated/AST/ObjCTypeParamType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OffsetOfExpr.cpp b/bindings/Python/Generated/AST/OffsetOfExpr.cpp
index 7d5fcd888..5aa673813 100644
--- a/bindings/Python/Generated/AST/OffsetOfExpr.cpp
+++ b/bindings/Python/Generated/AST/OffsetOfExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OffsetOfExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OffsetOfExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OffsetOfExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OffsetOfExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OpaqueValueExpr.cpp b/bindings/Python/Generated/AST/OpaqueValueExpr.cpp
index 8abba3bd0..cf4b87bf9 100644
--- a/bindings/Python/Generated/AST/OpaqueValueExpr.cpp
+++ b/bindings/Python/Generated/AST/OpaqueValueExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OpaqueValueExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OpaqueValueExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OpaqueValueExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OpaqueValueExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/OpenCLAccessAttr.cpp b/bindings/Python/Generated/AST/OpenCLAccessAttr.cpp
index dbb11a7a2..db6bd91a2 100644
--- a/bindings/Python/Generated/AST/OpenCLAccessAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLAccessAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -320,7 +319,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLConstantAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLConstantAddressSpaceAttr.cpp
index 61f38ad30..62d920ff0 100644
--- a/bindings/Python/Generated/AST/OpenCLConstantAddressSpaceAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLConstantAddressSpaceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLGenericAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLGenericAddressSpaceAttr.cpp
index 8e1365e91..f2dd23079 100644
--- a/bindings/Python/Generated/AST/OpenCLGenericAddressSpaceAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLGenericAddressSpaceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLGlobalAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLGlobalAddressSpaceAttr.cpp
index 3e0ac2079..c3b031fd5 100644
--- a/bindings/Python/Generated/AST/OpenCLGlobalAddressSpaceAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLGlobalAddressSpaceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLGlobalDeviceAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLGlobalDeviceAddressSpaceAttr.cpp
index e036bb2ba..1bdae147e 100644
--- a/bindings/Python/Generated/AST/OpenCLGlobalDeviceAddressSpaceAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLGlobalDeviceAddressSpaceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLGlobalHostAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLGlobalHostAddressSpaceAttr.cpp
index 640b4ae74..44f959994 100644
--- a/bindings/Python/Generated/AST/OpenCLGlobalHostAddressSpaceAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLGlobalHostAddressSpaceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLIntelReqdSubGroupSizeAttr.cpp b/bindings/Python/Generated/AST/OpenCLIntelReqdSubGroupSizeAttr.cpp
index ce3c8b1ab..0907db949 100644
--- a/bindings/Python/Generated/AST/OpenCLIntelReqdSubGroupSizeAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLIntelReqdSubGroupSizeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLKernelAttr.cpp b/bindings/Python/Generated/AST/OpenCLKernelAttr.cpp
index b55f82deb..ed2c6b919 100644
--- a/bindings/Python/Generated/AST/OpenCLKernelAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLKernelAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLLocalAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLLocalAddressSpaceAttr.cpp
index 395109f01..5e70476a0 100644
--- a/bindings/Python/Generated/AST/OpenCLLocalAddressSpaceAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLLocalAddressSpaceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLPrivateAddressSpaceAttr.cpp b/bindings/Python/Generated/AST/OpenCLPrivateAddressSpaceAttr.cpp
index 340ad2aaa..792f2ba53 100644
--- a/bindings/Python/Generated/AST/OpenCLPrivateAddressSpaceAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLPrivateAddressSpaceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OpenCLUnrollHintAttr.cpp b/bindings/Python/Generated/AST/OpenCLUnrollHintAttr.cpp
index 627f0fa67..4bb44ec42 100644
--- a/bindings/Python/Generated/AST/OpenCLUnrollHintAttr.cpp
+++ b/bindings/Python/Generated/AST/OpenCLUnrollHintAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OptimizeNoneAttr.cpp b/bindings/Python/Generated/AST/OptimizeNoneAttr.cpp
index e07531de4..dcfa5d130 100644
--- a/bindings/Python/Generated/AST/OptimizeNoneAttr.cpp
+++ b/bindings/Python/Generated/AST/OptimizeNoneAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OverloadExpr.cpp b/bindings/Python/Generated/AST/OverloadExpr.cpp
index e37924419..35137d2cf 100644
--- a/bindings/Python/Generated/AST/OverloadExpr.cpp
+++ b/bindings/Python/Generated/AST/OverloadExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -322,18 +321,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::OverloadExpr::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OverloadExpr::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::OverloadExpr::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -359,7 +396,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -382,52 +419,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::OverloadExpr::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OverloadExpr::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::OverloadExpr::from_base"),
-  },
   {
     "nth_declaration",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/OverloadableAttr.cpp b/bindings/Python/Generated/AST/OverloadableAttr.cpp
index 7285651fc..c9260d011 100644
--- a/bindings/Python/Generated/AST/OverloadableAttr.cpp
+++ b/bindings/Python/Generated/AST/OverloadableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OverrideAttr.cpp b/bindings/Python/Generated/AST/OverrideAttr.cpp
index f42c92a69..2e7cd1cf3 100644
--- a/bindings/Python/Generated/AST/OverrideAttr.cpp
+++ b/bindings/Python/Generated/AST/OverrideAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OwnerAttr.cpp b/bindings/Python/Generated/AST/OwnerAttr.cpp
index f2e4a1782..8f57ed024 100644
--- a/bindings/Python/Generated/AST/OwnerAttr.cpp
+++ b/bindings/Python/Generated/AST/OwnerAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/OwnershipAttr.cpp b/bindings/Python/Generated/AST/OwnershipAttr.cpp
index a04c0e49b..76b05c083 100644
--- a/bindings/Python/Generated/AST/OwnershipAttr.cpp
+++ b/bindings/Python/Generated/AST/OwnershipAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -330,7 +329,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PackExpansionExpr.cpp b/bindings/Python/Generated/AST/PackExpansionExpr.cpp
index 4bfb6e077..57d4c1388 100644
--- a/bindings/Python/Generated/AST/PackExpansionExpr.cpp
+++ b/bindings/Python/Generated/AST/PackExpansionExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PackExpansionExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::PackExpansionExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PackExpansionExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::PackExpansionExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/PackExpansionType.cpp b/bindings/Python/Generated/AST/PackExpansionType.cpp
index 6550f630c..fa4f3404e 100644
--- a/bindings/Python/Generated/AST/PackExpansionType.cpp
+++ b/bindings/Python/Generated/AST/PackExpansionType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PackedAttr.cpp b/bindings/Python/Generated/AST/PackedAttr.cpp
index 000c10718..fb64efdf5 100644
--- a/bindings/Python/Generated/AST/PackedAttr.cpp
+++ b/bindings/Python/Generated/AST/PackedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ParamTypestateAttr.cpp b/bindings/Python/Generated/AST/ParamTypestateAttr.cpp
index 28eb86a0e..fc9ee9577 100644
--- a/bindings/Python/Generated/AST/ParamTypestateAttr.cpp
+++ b/bindings/Python/Generated/AST/ParamTypestateAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ParameterABIAttr.cpp b/bindings/Python/Generated/AST/ParameterABIAttr.cpp
index dec292839..59e9201f1 100644
--- a/bindings/Python/Generated/AST/ParameterABIAttr.cpp
+++ b/bindings/Python/Generated/AST/ParameterABIAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -285,7 +284,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ParenExpr.cpp b/bindings/Python/Generated/AST/ParenExpr.cpp
index fc61752b6..8cb35c73a 100644
--- a/bindings/Python/Generated/AST/ParenExpr.cpp
+++ b/bindings/Python/Generated/AST/ParenExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ParenExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ParenExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ParenExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ParenExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ParenListExpr.cpp b/bindings/Python/Generated/AST/ParenListExpr.cpp
index 15a019154..1a61c7a16 100644
--- a/bindings/Python/Generated/AST/ParenListExpr.cpp
+++ b/bindings/Python/Generated/AST/ParenListExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ParenListExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ParenListExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ParenListExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ParenListExpr::from"),
+  },
   {
     "nth_expression",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/ParenType.cpp b/bindings/Python/Generated/AST/ParenType.cpp
index b1feae1c2..659b6f55b 100644
--- a/bindings/Python/Generated/AST/ParenType.cpp
+++ b/bindings/Python/Generated/AST/ParenType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ParmVarDecl.cpp b/bindings/Python/Generated/AST/ParmVarDecl.cpp
index 81551d9a7..93a29fda8 100644
--- a/bindings/Python/Generated/AST/ParmVarDecl.cpp
+++ b/bindings/Python/Generated/AST/ParmVarDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -417,67 +416,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ParmVarDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ParmVarDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -541,6 +479,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ParmVarDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ParmVarDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/PascalAttr.cpp b/bindings/Python/Generated/AST/PascalAttr.cpp
index 69f33571b..d5a50cf39 100644
--- a/bindings/Python/Generated/AST/PascalAttr.cpp
+++ b/bindings/Python/Generated/AST/PascalAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PassObjectSizeAttr.cpp b/bindings/Python/Generated/AST/PassObjectSizeAttr.cpp
index a4499b3a9..71cbc6567 100644
--- a/bindings/Python/Generated/AST/PassObjectSizeAttr.cpp
+++ b/bindings/Python/Generated/AST/PassObjectSizeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PatchableFunctionEntryAttr.cpp b/bindings/Python/Generated/AST/PatchableFunctionEntryAttr.cpp
index 4d5bc2cab..843ab0578 100644
--- a/bindings/Python/Generated/AST/PatchableFunctionEntryAttr.cpp
+++ b/bindings/Python/Generated/AST/PatchableFunctionEntryAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PcsAttr.cpp b/bindings/Python/Generated/AST/PcsAttr.cpp
index 60f1c7445..f196d6201 100644
--- a/bindings/Python/Generated/AST/PcsAttr.cpp
+++ b/bindings/Python/Generated/AST/PcsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PipeType.cpp b/bindings/Python/Generated/AST/PipeType.cpp
index 18c3a4609..14455151a 100644
--- a/bindings/Python/Generated/AST/PipeType.cpp
+++ b/bindings/Python/Generated/AST/PipeType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PointerAttr.cpp b/bindings/Python/Generated/AST/PointerAttr.cpp
index 7599afd45..c220e66bf 100644
--- a/bindings/Python/Generated/AST/PointerAttr.cpp
+++ b/bindings/Python/Generated/AST/PointerAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PointerType.cpp b/bindings/Python/Generated/AST/PointerType.cpp
index e79a6a0d3..5bd5c7fda 100644
--- a/bindings/Python/Generated/AST/PointerType.cpp
+++ b/bindings/Python/Generated/AST/PointerType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PragmaClangBSSSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangBSSSectionAttr.cpp
index c0079eb0d..f6b0150a0 100644
--- a/bindings/Python/Generated/AST/PragmaClangBSSSectionAttr.cpp
+++ b/bindings/Python/Generated/AST/PragmaClangBSSSectionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PragmaClangDataSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangDataSectionAttr.cpp
index e6f2b1c34..eaf62433c 100644
--- a/bindings/Python/Generated/AST/PragmaClangDataSectionAttr.cpp
+++ b/bindings/Python/Generated/AST/PragmaClangDataSectionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PragmaClangRelroSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangRelroSectionAttr.cpp
index 6a15fb348..900a792d7 100644
--- a/bindings/Python/Generated/AST/PragmaClangRelroSectionAttr.cpp
+++ b/bindings/Python/Generated/AST/PragmaClangRelroSectionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PragmaClangRodataSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangRodataSectionAttr.cpp
index b4188b8bf..98f5cb951 100644
--- a/bindings/Python/Generated/AST/PragmaClangRodataSectionAttr.cpp
+++ b/bindings/Python/Generated/AST/PragmaClangRodataSectionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PragmaClangTextSectionAttr.cpp b/bindings/Python/Generated/AST/PragmaClangTextSectionAttr.cpp
index 74afb0a04..1ac2bb194 100644
--- a/bindings/Python/Generated/AST/PragmaClangTextSectionAttr.cpp
+++ b/bindings/Python/Generated/AST/PragmaClangTextSectionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PragmaCommentDecl.cpp b/bindings/Python/Generated/AST/PragmaCommentDecl.cpp
index aafe1320f..09225534d 100644
--- a/bindings/Python/Generated/AST/PragmaCommentDecl.cpp
+++ b/bindings/Python/Generated/AST/PragmaCommentDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PragmaCommentDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::PragmaCommentDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PragmaCommentDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::PragmaCommentDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/PragmaDetectMismatchDecl.cpp b/bindings/Python/Generated/AST/PragmaDetectMismatchDecl.cpp
index 278918149..6a59e1f99 100644
--- a/bindings/Python/Generated/AST/PragmaDetectMismatchDecl.cpp
+++ b/bindings/Python/Generated/AST/PragmaDetectMismatchDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PragmaDetectMismatchDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::PragmaDetectMismatchDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PragmaDetectMismatchDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::PragmaDetectMismatchDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/PredefinedExpr.cpp b/bindings/Python/Generated/AST/PredefinedExpr.cpp
index 7d2990ee8..656ad2724 100644
--- a/bindings/Python/Generated/AST/PredefinedExpr.cpp
+++ b/bindings/Python/Generated/AST/PredefinedExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PredefinedExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::PredefinedExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PredefinedExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::PredefinedExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/PreferredNameAttr.cpp b/bindings/Python/Generated/AST/PreferredNameAttr.cpp
index 80986d763..6332a123f 100644
--- a/bindings/Python/Generated/AST/PreferredNameAttr.cpp
+++ b/bindings/Python/Generated/AST/PreferredNameAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PreferredTypeAttr.cpp b/bindings/Python/Generated/AST/PreferredTypeAttr.cpp
index 1654c99fa..f4950a44a 100644
--- a/bindings/Python/Generated/AST/PreferredTypeAttr.cpp
+++ b/bindings/Python/Generated/AST/PreferredTypeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PreserveAllAttr.cpp b/bindings/Python/Generated/AST/PreserveAllAttr.cpp
index 97b0bfde8..787a473ab 100644
--- a/bindings/Python/Generated/AST/PreserveAllAttr.cpp
+++ b/bindings/Python/Generated/AST/PreserveAllAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PreserveMostAttr.cpp b/bindings/Python/Generated/AST/PreserveMostAttr.cpp
index e844c2d0c..205295eab 100644
--- a/bindings/Python/Generated/AST/PreserveMostAttr.cpp
+++ b/bindings/Python/Generated/AST/PreserveMostAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PseudoObjectExpr.cpp b/bindings/Python/Generated/AST/PseudoObjectExpr.cpp
index da93f5e2e..a809884a6 100644
--- a/bindings/Python/Generated/AST/PseudoObjectExpr.cpp
+++ b/bindings/Python/Generated/AST/PseudoObjectExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PseudoObjectExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::PseudoObjectExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::PseudoObjectExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::PseudoObjectExpr::from"),
+  },
   {
     "nth_semantic",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/PtGuardedByAttr.cpp b/bindings/Python/Generated/AST/PtGuardedByAttr.cpp
index 968dfc9ef..e57088d39 100644
--- a/bindings/Python/Generated/AST/PtGuardedByAttr.cpp
+++ b/bindings/Python/Generated/AST/PtGuardedByAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PtGuardedVarAttr.cpp b/bindings/Python/Generated/AST/PtGuardedVarAttr.cpp
index d979be27a..1ae4f15d3 100644
--- a/bindings/Python/Generated/AST/PtGuardedVarAttr.cpp
+++ b/bindings/Python/Generated/AST/PtGuardedVarAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/Ptr32Attr.cpp b/bindings/Python/Generated/AST/Ptr32Attr.cpp
index c7c836865..13a4b8808 100644
--- a/bindings/Python/Generated/AST/Ptr32Attr.cpp
+++ b/bindings/Python/Generated/AST/Ptr32Attr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/Ptr64Attr.cpp b/bindings/Python/Generated/AST/Ptr64Attr.cpp
index 38b7e91bf..3db5d2219 100644
--- a/bindings/Python/Generated/AST/Ptr64Attr.cpp
+++ b/bindings/Python/Generated/AST/Ptr64Attr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/PureAttr.cpp b/bindings/Python/Generated/AST/PureAttr.cpp
index ba1af8bc6..8ee822f13 100644
--- a/bindings/Python/Generated/AST/PureAttr.cpp
+++ b/bindings/Python/Generated/AST/PureAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/QualifiedType.cpp b/bindings/Python/Generated/AST/QualifiedType.cpp
index f8e277670..5b725d2ab 100644
--- a/bindings/Python/Generated/AST/QualifiedType.cpp
+++ b/bindings/Python/Generated/AST/QualifiedType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -624,7 +623,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RISCVInterruptAttr.cpp b/bindings/Python/Generated/AST/RISCVInterruptAttr.cpp
index 651b3c5ca..c8c5faac4 100644
--- a/bindings/Python/Generated/AST/RISCVInterruptAttr.cpp
+++ b/bindings/Python/Generated/AST/RISCVInterruptAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RValueReferenceType.cpp b/bindings/Python/Generated/AST/RValueReferenceType.cpp
index a233a64fd..5f8a9465c 100644
--- a/bindings/Python/Generated/AST/RValueReferenceType.cpp
+++ b/bindings/Python/Generated/AST/RValueReferenceType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -274,7 +273,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RandomizeLayoutAttr.cpp b/bindings/Python/Generated/AST/RandomizeLayoutAttr.cpp
index 759a428a4..f8ff4abe3 100644
--- a/bindings/Python/Generated/AST/RandomizeLayoutAttr.cpp
+++ b/bindings/Python/Generated/AST/RandomizeLayoutAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ReadOnlyPlacementAttr.cpp b/bindings/Python/Generated/AST/ReadOnlyPlacementAttr.cpp
index 14f3d6d6b..20a2a356c 100644
--- a/bindings/Python/Generated/AST/ReadOnlyPlacementAttr.cpp
+++ b/bindings/Python/Generated/AST/ReadOnlyPlacementAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RecordDecl.cpp b/bindings/Python/Generated/AST/RecordDecl.cpp
index 1523c49c4..e0389f576 100644
--- a/bindings/Python/Generated/AST/RecordDecl.cpp
+++ b/bindings/Python/Generated/AST/RecordDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -529,67 +528,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::RecordDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::RecordDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -653,6 +591,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::RecordDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::RecordDecl::from"),
+  },
   {
     "nth_field",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/RecordType.cpp b/bindings/Python/Generated/AST/RecordType.cpp
index 92b662a8a..61004ecdb 100644
--- a/bindings/Python/Generated/AST/RecordType.cpp
+++ b/bindings/Python/Generated/AST/RecordType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RecoveryExpr.cpp b/bindings/Python/Generated/AST/RecoveryExpr.cpp
index 6da58dda8..a581ab28f 100644
--- a/bindings/Python/Generated/AST/RecoveryExpr.cpp
+++ b/bindings/Python/Generated/AST/RecoveryExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::RecoveryExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::RecoveryExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::RecoveryExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::RecoveryExpr::from"),
+  },
   {
     "nth_sub_expression",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/RedeclarableTemplateDecl.cpp b/bindings/Python/Generated/AST/RedeclarableTemplateDecl.cpp
index e689bf9de..9917e1529 100644
--- a/bindings/Python/Generated/AST/RedeclarableTemplateDecl.cpp
+++ b/bindings/Python/Generated/AST/RedeclarableTemplateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,18 +279,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::RedeclarableTemplateDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::RedeclarableTemplateDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::RedeclarableTemplateDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -317,7 +354,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -340,52 +377,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::RedeclarableTemplateDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::RedeclarableTemplateDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::RedeclarableTemplateDecl::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ReferenceType.cpp b/bindings/Python/Generated/AST/ReferenceType.cpp
index 89d569be8..cc07f2608 100644
--- a/bindings/Python/Generated/AST/ReferenceType.cpp
+++ b/bindings/Python/Generated/AST/ReferenceType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -291,7 +290,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RegCallAttr.cpp b/bindings/Python/Generated/AST/RegCallAttr.cpp
index f1bdaef11..3f4db4436 100644
--- a/bindings/Python/Generated/AST/RegCallAttr.cpp
+++ b/bindings/Python/Generated/AST/RegCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ReinitializesAttr.cpp b/bindings/Python/Generated/AST/ReinitializesAttr.cpp
index cf1fdb0d4..68cc4b089 100644
--- a/bindings/Python/Generated/AST/ReinitializesAttr.cpp
+++ b/bindings/Python/Generated/AST/ReinitializesAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ReleaseCapabilityAttr.cpp b/bindings/Python/Generated/AST/ReleaseCapabilityAttr.cpp
index ddae9e854..d71f4cf57 100644
--- a/bindings/Python/Generated/AST/ReleaseCapabilityAttr.cpp
+++ b/bindings/Python/Generated/AST/ReleaseCapabilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ReleaseHandleAttr.cpp b/bindings/Python/Generated/AST/ReleaseHandleAttr.cpp
index 24b41af75..ea733840b 100644
--- a/bindings/Python/Generated/AST/ReleaseHandleAttr.cpp
+++ b/bindings/Python/Generated/AST/ReleaseHandleAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RenderScriptKernelAttr.cpp b/bindings/Python/Generated/AST/RenderScriptKernelAttr.cpp
index 1bc1da103..0adef67af 100644
--- a/bindings/Python/Generated/AST/RenderScriptKernelAttr.cpp
+++ b/bindings/Python/Generated/AST/RenderScriptKernelAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ReqdWorkGroupSizeAttr.cpp b/bindings/Python/Generated/AST/ReqdWorkGroupSizeAttr.cpp
index 86c7306d1..364697248 100644
--- a/bindings/Python/Generated/AST/ReqdWorkGroupSizeAttr.cpp
+++ b/bindings/Python/Generated/AST/ReqdWorkGroupSizeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RequiresCapabilityAttr.cpp b/bindings/Python/Generated/AST/RequiresCapabilityAttr.cpp
index 441f2be9c..18a5bde5c 100644
--- a/bindings/Python/Generated/AST/RequiresCapabilityAttr.cpp
+++ b/bindings/Python/Generated/AST/RequiresCapabilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RequiresExpr.cpp b/bindings/Python/Generated/AST/RequiresExpr.cpp
index 15bcf0990..775dffeac 100644
--- a/bindings/Python/Generated/AST/RequiresExpr.cpp
+++ b/bindings/Python/Generated/AST/RequiresExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::RequiresExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::RequiresExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::RequiresExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::RequiresExpr::from"),
+  },
   {
     "nth_local_parameter",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/RequiresExprBodyDecl.cpp b/bindings/Python/Generated/AST/RequiresExprBodyDecl.cpp
index cef2cfbf5..96a8a36cb 100644
--- a/bindings/Python/Generated/AST/RequiresExprBodyDecl.cpp
+++ b/bindings/Python/Generated/AST/RequiresExprBodyDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::RequiresExprBodyDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::RequiresExprBodyDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::RequiresExprBodyDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::RequiresExprBodyDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/RestrictAttr.cpp b/bindings/Python/Generated/AST/RestrictAttr.cpp
index 8312f99ce..91db6a04e 100644
--- a/bindings/Python/Generated/AST/RestrictAttr.cpp
+++ b/bindings/Python/Generated/AST/RestrictAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/RetainAttr.cpp b/bindings/Python/Generated/AST/RetainAttr.cpp
index 189bdae65..7b1a6429f 100644
--- a/bindings/Python/Generated/AST/RetainAttr.cpp
+++ b/bindings/Python/Generated/AST/RetainAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ReturnStmt.cpp b/bindings/Python/Generated/AST/ReturnStmt.cpp
index 3a0c34be2..1ca1c408c 100644
--- a/bindings/Python/Generated/AST/ReturnStmt.cpp
+++ b/bindings/Python/Generated/AST/ReturnStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ReturnStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ReturnStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ReturnStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ReturnStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ReturnTypestateAttr.cpp b/bindings/Python/Generated/AST/ReturnTypestateAttr.cpp
index cfdf88659..668f4ac0b 100644
--- a/bindings/Python/Generated/AST/ReturnTypestateAttr.cpp
+++ b/bindings/Python/Generated/AST/ReturnTypestateAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ReturnsNonNullAttr.cpp b/bindings/Python/Generated/AST/ReturnsNonNullAttr.cpp
index 0265b9be4..fbc702c90 100644
--- a/bindings/Python/Generated/AST/ReturnsNonNullAttr.cpp
+++ b/bindings/Python/Generated/AST/ReturnsNonNullAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ReturnsTwiceAttr.cpp b/bindings/Python/Generated/AST/ReturnsTwiceAttr.cpp
index c337b8b58..c84b6fcaf 100644
--- a/bindings/Python/Generated/AST/ReturnsTwiceAttr.cpp
+++ b/bindings/Python/Generated/AST/ReturnsTwiceAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SEHExceptStmt.cpp b/bindings/Python/Generated/AST/SEHExceptStmt.cpp
index c03d9f50f..01aa6ff91 100644
--- a/bindings/Python/Generated/AST/SEHExceptStmt.cpp
+++ b/bindings/Python/Generated/AST/SEHExceptStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SEHExceptStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SEHExceptStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SEHExceptStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SEHExceptStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SEHFinallyStmt.cpp b/bindings/Python/Generated/AST/SEHFinallyStmt.cpp
index 445eb0a12..4e929bed8 100644
--- a/bindings/Python/Generated/AST/SEHFinallyStmt.cpp
+++ b/bindings/Python/Generated/AST/SEHFinallyStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SEHFinallyStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SEHFinallyStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SEHFinallyStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SEHFinallyStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SEHLeaveStmt.cpp b/bindings/Python/Generated/AST/SEHLeaveStmt.cpp
index 51b6b01a0..25a54bc5f 100644
--- a/bindings/Python/Generated/AST/SEHLeaveStmt.cpp
+++ b/bindings/Python/Generated/AST/SEHLeaveStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -237,67 +236,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SEHLeaveStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SEHLeaveStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -361,6 +299,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SEHLeaveStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SEHLeaveStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SEHTryStmt.cpp b/bindings/Python/Generated/AST/SEHTryStmt.cpp
index cabafb4cd..15e301583 100644
--- a/bindings/Python/Generated/AST/SEHTryStmt.cpp
+++ b/bindings/Python/Generated/AST/SEHTryStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SEHTryStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SEHTryStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SEHTryStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SEHTryStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SPtrAttr.cpp b/bindings/Python/Generated/AST/SPtrAttr.cpp
index fa82b3fdf..a26efab23 100644
--- a/bindings/Python/Generated/AST/SPtrAttr.cpp
+++ b/bindings/Python/Generated/AST/SPtrAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SYCLKernelAttr.cpp b/bindings/Python/Generated/AST/SYCLKernelAttr.cpp
index c647eafa5..b144c3d3c 100644
--- a/bindings/Python/Generated/AST/SYCLKernelAttr.cpp
+++ b/bindings/Python/Generated/AST/SYCLKernelAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SYCLSpecialClassAttr.cpp b/bindings/Python/Generated/AST/SYCLSpecialClassAttr.cpp
index aa3da55a9..673262b04 100644
--- a/bindings/Python/Generated/AST/SYCLSpecialClassAttr.cpp
+++ b/bindings/Python/Generated/AST/SYCLSpecialClassAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SYCLUniqueStableNameExpr.cpp b/bindings/Python/Generated/AST/SYCLUniqueStableNameExpr.cpp
index 4d077ba58..6e1ffe264 100644
--- a/bindings/Python/Generated/AST/SYCLUniqueStableNameExpr.cpp
+++ b/bindings/Python/Generated/AST/SYCLUniqueStableNameExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SYCLUniqueStableNameExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SYCLUniqueStableNameExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SYCLUniqueStableNameExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SYCLUniqueStableNameExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ScopedLockableAttr.cpp b/bindings/Python/Generated/AST/ScopedLockableAttr.cpp
index 713f2ec3a..32e2b2205 100644
--- a/bindings/Python/Generated/AST/ScopedLockableAttr.cpp
+++ b/bindings/Python/Generated/AST/ScopedLockableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SectionAttr.cpp b/bindings/Python/Generated/AST/SectionAttr.cpp
index cd8ecd8a6..5b14cce8e 100644
--- a/bindings/Python/Generated/AST/SectionAttr.cpp
+++ b/bindings/Python/Generated/AST/SectionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SelectAnyAttr.cpp b/bindings/Python/Generated/AST/SelectAnyAttr.cpp
index 2b57c7ae6..4598b40d4 100644
--- a/bindings/Python/Generated/AST/SelectAnyAttr.cpp
+++ b/bindings/Python/Generated/AST/SelectAnyAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SentinelAttr.cpp b/bindings/Python/Generated/AST/SentinelAttr.cpp
index b10d30287..db19e81bc 100644
--- a/bindings/Python/Generated/AST/SentinelAttr.cpp
+++ b/bindings/Python/Generated/AST/SentinelAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SetTypestateAttr.cpp b/bindings/Python/Generated/AST/SetTypestateAttr.cpp
index 224672e5f..f9764d419 100644
--- a/bindings/Python/Generated/AST/SetTypestateAttr.cpp
+++ b/bindings/Python/Generated/AST/SetTypestateAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SharedTrylockFunctionAttr.cpp b/bindings/Python/Generated/AST/SharedTrylockFunctionAttr.cpp
index aecc7cfd4..450e209e3 100644
--- a/bindings/Python/Generated/AST/SharedTrylockFunctionAttr.cpp
+++ b/bindings/Python/Generated/AST/SharedTrylockFunctionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ShuffleVectorExpr.cpp b/bindings/Python/Generated/AST/ShuffleVectorExpr.cpp
index 8bacef419..ce71a816c 100644
--- a/bindings/Python/Generated/AST/ShuffleVectorExpr.cpp
+++ b/bindings/Python/Generated/AST/ShuffleVectorExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ShuffleVectorExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ShuffleVectorExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ShuffleVectorExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ShuffleVectorExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SizeOfPackExpr.cpp b/bindings/Python/Generated/AST/SizeOfPackExpr.cpp
index d9d6cc7e5..2953f4c91 100644
--- a/bindings/Python/Generated/AST/SizeOfPackExpr.cpp
+++ b/bindings/Python/Generated/AST/SizeOfPackExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SizeOfPackExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SizeOfPackExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SizeOfPackExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SizeOfPackExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SourceLocExpr.cpp b/bindings/Python/Generated/AST/SourceLocExpr.cpp
index c8e2cb2f7..fee881060 100644
--- a/bindings/Python/Generated/AST/SourceLocExpr.cpp
+++ b/bindings/Python/Generated/AST/SourceLocExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SourceLocExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SourceLocExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SourceLocExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SourceLocExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SpeculativeLoadHardeningAttr.cpp b/bindings/Python/Generated/AST/SpeculativeLoadHardeningAttr.cpp
index 0b77e0636..e5cd3cb5f 100644
--- a/bindings/Python/Generated/AST/SpeculativeLoadHardeningAttr.cpp
+++ b/bindings/Python/Generated/AST/SpeculativeLoadHardeningAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/StandaloneDebugAttr.cpp b/bindings/Python/Generated/AST/StandaloneDebugAttr.cpp
index 046e77212..c0d3fb3ca 100644
--- a/bindings/Python/Generated/AST/StandaloneDebugAttr.cpp
+++ b/bindings/Python/Generated/AST/StandaloneDebugAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/StaticAssertDecl.cpp b/bindings/Python/Generated/AST/StaticAssertDecl.cpp
index 25543e585..496768b90 100644
--- a/bindings/Python/Generated/AST/StaticAssertDecl.cpp
+++ b/bindings/Python/Generated/AST/StaticAssertDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::StaticAssertDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::StaticAssertDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::StaticAssertDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::StaticAssertDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/StdCallAttr.cpp b/bindings/Python/Generated/AST/StdCallAttr.cpp
index 93ed1bd59..434a48a6c 100644
--- a/bindings/Python/Generated/AST/StdCallAttr.cpp
+++ b/bindings/Python/Generated/AST/StdCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/Stmt.cpp b/bindings/Python/Generated/AST/Stmt.cpp
index c28b2b124..098d11baa 100644
--- a/bindings/Python/Generated/AST/Stmt.cpp
+++ b/bindings/Python/Generated/AST/Stmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -1325,18 +1324,35 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::Stmt::containing"),
   },
   {
-    "FROM",
+    "by_id",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::Stmt::by_id"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -1362,7 +1378,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -1385,31 +1401,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::Stmt::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::Stmt::by_id"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/StmtAttr.cpp b/bindings/Python/Generated/AST/StmtAttr.cpp
index 9384f0343..dd7caf8d6 100644
--- a/bindings/Python/Generated/AST/StmtAttr.cpp
+++ b/bindings/Python/Generated/AST/StmtAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -283,7 +282,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/StmtExpr.cpp b/bindings/Python/Generated/AST/StmtExpr.cpp
index ec3737fb3..f5ce5e917 100644
--- a/bindings/Python/Generated/AST/StmtExpr.cpp
+++ b/bindings/Python/Generated/AST/StmtExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::StmtExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::StmtExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::StmtExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::StmtExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/StrictFPAttr.cpp b/bindings/Python/Generated/AST/StrictFPAttr.cpp
index 625aeba76..e043a32ea 100644
--- a/bindings/Python/Generated/AST/StrictFPAttr.cpp
+++ b/bindings/Python/Generated/AST/StrictFPAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/StrictGuardStackCheckAttr.cpp b/bindings/Python/Generated/AST/StrictGuardStackCheckAttr.cpp
index 65f556cc2..c26016890 100644
--- a/bindings/Python/Generated/AST/StrictGuardStackCheckAttr.cpp
+++ b/bindings/Python/Generated/AST/StrictGuardStackCheckAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/StringLiteral.cpp b/bindings/Python/Generated/AST/StringLiteral.cpp
index 2ecccfaa2..6bae4242a 100644
--- a/bindings/Python/Generated/AST/StringLiteral.cpp
+++ b/bindings/Python/Generated/AST/StringLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -387,67 +386,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::StringLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::StringLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -511,6 +449,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::StringLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::StringLiteral::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SubstNonTypeTemplateParmExpr.cpp b/bindings/Python/Generated/AST/SubstNonTypeTemplateParmExpr.cpp
index e2d4aff75..819bd5a94 100644
--- a/bindings/Python/Generated/AST/SubstNonTypeTemplateParmExpr.cpp
+++ b/bindings/Python/Generated/AST/SubstNonTypeTemplateParmExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SubstNonTypeTemplateParmExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SubstNonTypeTemplateParmExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SubstNonTypeTemplateParmExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SubstNonTypeTemplateParmExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SubstNonTypeTemplateParmPackExpr.cpp b/bindings/Python/Generated/AST/SubstNonTypeTemplateParmPackExpr.cpp
index b436f9abb..d17bfd532 100644
--- a/bindings/Python/Generated/AST/SubstNonTypeTemplateParmPackExpr.cpp
+++ b/bindings/Python/Generated/AST/SubstNonTypeTemplateParmPackExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SubstNonTypeTemplateParmPackExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SubstNonTypeTemplateParmPackExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SubstNonTypeTemplateParmPackExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SubstNonTypeTemplateParmPackExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SubstTemplateTypeParmPackType.cpp b/bindings/Python/Generated/AST/SubstTemplateTypeParmPackType.cpp
index c1d45dbaf..21b38a308 100644
--- a/bindings/Python/Generated/AST/SubstTemplateTypeParmPackType.cpp
+++ b/bindings/Python/Generated/AST/SubstTemplateTypeParmPackType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -314,7 +313,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SubstTemplateTypeParmType.cpp b/bindings/Python/Generated/AST/SubstTemplateTypeParmType.cpp
index 66de4eaee..63b27f028 100644
--- a/bindings/Python/Generated/AST/SubstTemplateTypeParmType.cpp
+++ b/bindings/Python/Generated/AST/SubstTemplateTypeParmType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -324,7 +323,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SuppressAttr.cpp b/bindings/Python/Generated/AST/SuppressAttr.cpp
index b00e8d893..60ad62f2e 100644
--- a/bindings/Python/Generated/AST/SuppressAttr.cpp
+++ b/bindings/Python/Generated/AST/SuppressAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftAsyncAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncAttr.cpp
index 4cc78d6ef..58f274ad4 100644
--- a/bindings/Python/Generated/AST/SwiftAsyncAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftAsyncAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftAsyncCallAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncCallAttr.cpp
index be3da00ea..8683565bf 100644
--- a/bindings/Python/Generated/AST/SwiftAsyncCallAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftAsyncCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftAsyncContextAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncContextAttr.cpp
index 685588832..521ccddae 100644
--- a/bindings/Python/Generated/AST/SwiftAsyncContextAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftAsyncContextAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftAsyncErrorAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncErrorAttr.cpp
index 1c44cc14b..061e944df 100644
--- a/bindings/Python/Generated/AST/SwiftAsyncErrorAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftAsyncErrorAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftAsyncNameAttr.cpp b/bindings/Python/Generated/AST/SwiftAsyncNameAttr.cpp
index be16c8597..efba67cba 100644
--- a/bindings/Python/Generated/AST/SwiftAsyncNameAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftAsyncNameAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftAttrAttr.cpp b/bindings/Python/Generated/AST/SwiftAttrAttr.cpp
index 0da3310ad..3e855bcc1 100644
--- a/bindings/Python/Generated/AST/SwiftAttrAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftAttrAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftBridgeAttr.cpp b/bindings/Python/Generated/AST/SwiftBridgeAttr.cpp
index 64ab6d230..8fd0c1f7d 100644
--- a/bindings/Python/Generated/AST/SwiftBridgeAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftBridgeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftBridgedTypedefAttr.cpp b/bindings/Python/Generated/AST/SwiftBridgedTypedefAttr.cpp
index 62933168f..5eb50dc14 100644
--- a/bindings/Python/Generated/AST/SwiftBridgedTypedefAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftBridgedTypedefAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftCallAttr.cpp b/bindings/Python/Generated/AST/SwiftCallAttr.cpp
index a0cd3e3de..509999b9c 100644
--- a/bindings/Python/Generated/AST/SwiftCallAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftContextAttr.cpp b/bindings/Python/Generated/AST/SwiftContextAttr.cpp
index 2f8852aa3..0224695bf 100644
--- a/bindings/Python/Generated/AST/SwiftContextAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftContextAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftErrorAttr.cpp b/bindings/Python/Generated/AST/SwiftErrorAttr.cpp
index 4699c82e8..f765eb5fb 100644
--- a/bindings/Python/Generated/AST/SwiftErrorAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftErrorAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftErrorResultAttr.cpp b/bindings/Python/Generated/AST/SwiftErrorResultAttr.cpp
index ecd65492b..7d28a408a 100644
--- a/bindings/Python/Generated/AST/SwiftErrorResultAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftErrorResultAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftImportAsNonGenericAttr.cpp b/bindings/Python/Generated/AST/SwiftImportAsNonGenericAttr.cpp
index 2322c72d4..3a306843f 100644
--- a/bindings/Python/Generated/AST/SwiftImportAsNonGenericAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftImportAsNonGenericAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftImportPropertyAsAccessorsAttr.cpp b/bindings/Python/Generated/AST/SwiftImportPropertyAsAccessorsAttr.cpp
index 85ea53cc3..58cc1ae42 100644
--- a/bindings/Python/Generated/AST/SwiftImportPropertyAsAccessorsAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftImportPropertyAsAccessorsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftIndirectResultAttr.cpp b/bindings/Python/Generated/AST/SwiftIndirectResultAttr.cpp
index 213dd48fe..d6e97a386 100644
--- a/bindings/Python/Generated/AST/SwiftIndirectResultAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftIndirectResultAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftNameAttr.cpp b/bindings/Python/Generated/AST/SwiftNameAttr.cpp
index f3c6875b5..66a7bc2ae 100644
--- a/bindings/Python/Generated/AST/SwiftNameAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftNameAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftNewTypeAttr.cpp b/bindings/Python/Generated/AST/SwiftNewTypeAttr.cpp
index 812c69fa3..a9212887b 100644
--- a/bindings/Python/Generated/AST/SwiftNewTypeAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftNewTypeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftObjCMembersAttr.cpp b/bindings/Python/Generated/AST/SwiftObjCMembersAttr.cpp
index fe5ff363a..fbe4548c9 100644
--- a/bindings/Python/Generated/AST/SwiftObjCMembersAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftObjCMembersAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftPrivateAttr.cpp b/bindings/Python/Generated/AST/SwiftPrivateAttr.cpp
index 7758724a8..23080bbc7 100644
--- a/bindings/Python/Generated/AST/SwiftPrivateAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftPrivateAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftVersionedAdditionAttr.cpp b/bindings/Python/Generated/AST/SwiftVersionedAdditionAttr.cpp
index 9d3eb2ef7..be3f0b602 100644
--- a/bindings/Python/Generated/AST/SwiftVersionedAdditionAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftVersionedAdditionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwiftVersionedRemovalAttr.cpp b/bindings/Python/Generated/AST/SwiftVersionedRemovalAttr.cpp
index 6d310f0ad..b2952c164 100644
--- a/bindings/Python/Generated/AST/SwiftVersionedRemovalAttr.cpp
+++ b/bindings/Python/Generated/AST/SwiftVersionedRemovalAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/SwitchCase.cpp b/bindings/Python/Generated/AST/SwitchCase.cpp
index 3a1610bf6..89836b075 100644
--- a/bindings/Python/Generated/AST/SwitchCase.cpp
+++ b/bindings/Python/Generated/AST/SwitchCase.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -272,18 +271,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::SwitchCase::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SwitchCase::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SwitchCase::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -309,7 +346,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -332,52 +369,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SwitchCase::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SwitchCase::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SwitchCase::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SwitchStmt.cpp b/bindings/Python/Generated/AST/SwitchStmt.cpp
index 1eea0a019..789776568 100644
--- a/bindings/Python/Generated/AST/SwitchStmt.cpp
+++ b/bindings/Python/Generated/AST/SwitchStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -347,67 +346,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SwitchStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::SwitchStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -471,6 +409,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::SwitchStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::SwitchStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/SysVABIAttr.cpp b/bindings/Python/Generated/AST/SysVABIAttr.cpp
index be35e16af..29db06731 100644
--- a/bindings/Python/Generated/AST/SysVABIAttr.cpp
+++ b/bindings/Python/Generated/AST/SysVABIAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TLSModelAttr.cpp b/bindings/Python/Generated/AST/TLSModelAttr.cpp
index 66bf52f26..5c08180bc 100644
--- a/bindings/Python/Generated/AST/TLSModelAttr.cpp
+++ b/bindings/Python/Generated/AST/TLSModelAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TagDecl.cpp b/bindings/Python/Generated/AST/TagDecl.cpp
index 85132cb80..8dc4d126c 100644
--- a/bindings/Python/Generated/AST/TagDecl.cpp
+++ b/bindings/Python/Generated/AST/TagDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -494,18 +493,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::TagDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TagDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TagDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -531,7 +568,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -554,52 +591,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TagDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TagDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TagDecl::from_base"),
-  },
   {
     "nth_template_parameter_list",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/TagType.cpp b/bindings/Python/Generated/AST/TagType.cpp
index 5f39c843b..9398108f4 100644
--- a/bindings/Python/Generated/AST/TagType.cpp
+++ b/bindings/Python/Generated/AST/TagType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -271,7 +270,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TargetAttr.cpp b/bindings/Python/Generated/AST/TargetAttr.cpp
index 6513ecfd6..cb69128e3 100644
--- a/bindings/Python/Generated/AST/TargetAttr.cpp
+++ b/bindings/Python/Generated/AST/TargetAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -320,7 +319,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TargetClonesAttr.cpp b/bindings/Python/Generated/AST/TargetClonesAttr.cpp
index e52f58629..56651c795 100644
--- a/bindings/Python/Generated/AST/TargetClonesAttr.cpp
+++ b/bindings/Python/Generated/AST/TargetClonesAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TargetVersionAttr.cpp b/bindings/Python/Generated/AST/TargetVersionAttr.cpp
index f1eea8d5d..ff2c1cabd 100644
--- a/bindings/Python/Generated/AST/TargetVersionAttr.cpp
+++ b/bindings/Python/Generated/AST/TargetVersionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -320,7 +319,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TemplateArgument.cpp b/bindings/Python/Generated/AST/TemplateArgument.cpp
index 43aa50947..fbc4cb5a6 100644
--- a/bindings/Python/Generated/AST/TemplateArgument.cpp
+++ b/bindings/Python/Generated/AST/TemplateArgument.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -415,7 +414,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TemplateDecl.cpp b/bindings/Python/Generated/AST/TemplateDecl.cpp
index dd6d4f771..6a26aac52 100644
--- a/bindings/Python/Generated/AST/TemplateDecl.cpp
+++ b/bindings/Python/Generated/AST/TemplateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -322,18 +321,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::TemplateDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TemplateDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TemplateDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -359,7 +396,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -382,52 +419,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TemplateDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TemplateDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TemplateDecl::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TemplateParamObjectDecl.cpp b/bindings/Python/Generated/AST/TemplateParamObjectDecl.cpp
index 90247ea0b..b86d8723b 100644
--- a/bindings/Python/Generated/AST/TemplateParamObjectDecl.cpp
+++ b/bindings/Python/Generated/AST/TemplateParamObjectDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TemplateParamObjectDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TemplateParamObjectDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TemplateParamObjectDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TemplateParamObjectDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TemplateParameterList.cpp b/bindings/Python/Generated/AST/TemplateParameterList.cpp
index 14c8025b5..e9d7e7589 100644
--- a/bindings/Python/Generated/AST/TemplateParameterList.cpp
+++ b/bindings/Python/Generated/AST/TemplateParameterList.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -367,7 +366,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TemplateSpecializationType.cpp b/bindings/Python/Generated/AST/TemplateSpecializationType.cpp
index 371fce0ac..af6c226f2 100644
--- a/bindings/Python/Generated/AST/TemplateSpecializationType.cpp
+++ b/bindings/Python/Generated/AST/TemplateSpecializationType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -324,7 +323,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TemplateTemplateParmDecl.cpp b/bindings/Python/Generated/AST/TemplateTemplateParmDecl.cpp
index 00eb45f6f..7981e6552 100644
--- a/bindings/Python/Generated/AST/TemplateTemplateParmDecl.cpp
+++ b/bindings/Python/Generated/AST/TemplateTemplateParmDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TemplateTemplateParmDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TemplateTemplateParmDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TemplateTemplateParmDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TemplateTemplateParmDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TemplateTypeParmDecl.cpp b/bindings/Python/Generated/AST/TemplateTypeParmDecl.cpp
index 4ea89fdd1..afdd800c2 100644
--- a/bindings/Python/Generated/AST/TemplateTypeParmDecl.cpp
+++ b/bindings/Python/Generated/AST/TemplateTypeParmDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -367,67 +366,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TemplateTypeParmDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TemplateTypeParmDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -491,6 +429,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TemplateTypeParmDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TemplateTypeParmDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TemplateTypeParmType.cpp b/bindings/Python/Generated/AST/TemplateTypeParmType.cpp
index e83f12df6..14abde391 100644
--- a/bindings/Python/Generated/AST/TemplateTypeParmType.cpp
+++ b/bindings/Python/Generated/AST/TemplateTypeParmType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -314,7 +313,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TestTypestateAttr.cpp b/bindings/Python/Generated/AST/TestTypestateAttr.cpp
index 9a22e37a1..d1f305d66 100644
--- a/bindings/Python/Generated/AST/TestTypestateAttr.cpp
+++ b/bindings/Python/Generated/AST/TestTypestateAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ThisCallAttr.cpp b/bindings/Python/Generated/AST/ThisCallAttr.cpp
index 3d3bdbce8..96026c3be 100644
--- a/bindings/Python/Generated/AST/ThisCallAttr.cpp
+++ b/bindings/Python/Generated/AST/ThisCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ThreadAttr.cpp b/bindings/Python/Generated/AST/ThreadAttr.cpp
index a0966d02a..09b3ca56d 100644
--- a/bindings/Python/Generated/AST/ThreadAttr.cpp
+++ b/bindings/Python/Generated/AST/ThreadAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TopLevelStmtDecl.cpp b/bindings/Python/Generated/AST/TopLevelStmtDecl.cpp
index 63101aaa2..ace5c5d27 100644
--- a/bindings/Python/Generated/AST/TopLevelStmtDecl.cpp
+++ b/bindings/Python/Generated/AST/TopLevelStmtDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TopLevelStmtDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TopLevelStmtDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TopLevelStmtDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TopLevelStmtDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TranslationUnitDecl.cpp b/bindings/Python/Generated/AST/TranslationUnitDecl.cpp
index 4510c098f..e4f9d177e 100644
--- a/bindings/Python/Generated/AST/TranslationUnitDecl.cpp
+++ b/bindings/Python/Generated/AST/TranslationUnitDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TranslationUnitDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TranslationUnitDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TranslationUnitDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TranslationUnitDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TransparentUnionAttr.cpp b/bindings/Python/Generated/AST/TransparentUnionAttr.cpp
index 74e1f8b27..310d7a398 100644
--- a/bindings/Python/Generated/AST/TransparentUnionAttr.cpp
+++ b/bindings/Python/Generated/AST/TransparentUnionAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TrivialABIAttr.cpp b/bindings/Python/Generated/AST/TrivialABIAttr.cpp
index 8d5a2e1a9..7934122d6 100644
--- a/bindings/Python/Generated/AST/TrivialABIAttr.cpp
+++ b/bindings/Python/Generated/AST/TrivialABIAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TryAcquireCapabilityAttr.cpp b/bindings/Python/Generated/AST/TryAcquireCapabilityAttr.cpp
index fde0f6ffb..c3af82195 100644
--- a/bindings/Python/Generated/AST/TryAcquireCapabilityAttr.cpp
+++ b/bindings/Python/Generated/AST/TryAcquireCapabilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/Type.cpp b/bindings/Python/Generated/AST/Type.cpp
index e01e5f713..6ca7ed80d 100644
--- a/bindings/Python/Generated/AST/Type.cpp
+++ b/bindings/Python/Generated/AST/Type.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -671,7 +670,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeAliasDecl.cpp b/bindings/Python/Generated/AST/TypeAliasDecl.cpp
index ab56888b3..7dd2d8a10 100644
--- a/bindings/Python/Generated/AST/TypeAliasDecl.cpp
+++ b/bindings/Python/Generated/AST/TypeAliasDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypeAliasDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TypeAliasDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypeAliasDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TypeAliasDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TypeAliasTemplateDecl.cpp b/bindings/Python/Generated/AST/TypeAliasTemplateDecl.cpp
index e8a9d03c2..664e26d75 100644
--- a/bindings/Python/Generated/AST/TypeAliasTemplateDecl.cpp
+++ b/bindings/Python/Generated/AST/TypeAliasTemplateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypeAliasTemplateDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TypeAliasTemplateDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypeAliasTemplateDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TypeAliasTemplateDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TypeAttr.cpp b/bindings/Python/Generated/AST/TypeAttr.cpp
index 2def635d5..080a21870 100644
--- a/bindings/Python/Generated/AST/TypeAttr.cpp
+++ b/bindings/Python/Generated/AST/TypeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -391,7 +390,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeDecl.cpp b/bindings/Python/Generated/AST/TypeDecl.cpp
index d855596e7..971988456 100644
--- a/bindings/Python/Generated/AST/TypeDecl.cpp
+++ b/bindings/Python/Generated/AST/TypeDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -304,18 +303,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::TypeDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TypeDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TypeDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -341,7 +378,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -364,52 +401,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypeDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TypeDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TypeDecl::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TypeNonNullAttr.cpp b/bindings/Python/Generated/AST/TypeNonNullAttr.cpp
index 2148d8e33..1675d7d3f 100644
--- a/bindings/Python/Generated/AST/TypeNonNullAttr.cpp
+++ b/bindings/Python/Generated/AST/TypeNonNullAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeNullUnspecifiedAttr.cpp b/bindings/Python/Generated/AST/TypeNullUnspecifiedAttr.cpp
index 04cbc1ce1..6900e2cee 100644
--- a/bindings/Python/Generated/AST/TypeNullUnspecifiedAttr.cpp
+++ b/bindings/Python/Generated/AST/TypeNullUnspecifiedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeNullableAttr.cpp b/bindings/Python/Generated/AST/TypeNullableAttr.cpp
index ecb89995a..b2d20d1b5 100644
--- a/bindings/Python/Generated/AST/TypeNullableAttr.cpp
+++ b/bindings/Python/Generated/AST/TypeNullableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeNullableResultAttr.cpp b/bindings/Python/Generated/AST/TypeNullableResultAttr.cpp
index 0101cbee3..63820a31a 100644
--- a/bindings/Python/Generated/AST/TypeNullableResultAttr.cpp
+++ b/bindings/Python/Generated/AST/TypeNullableResultAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeOfExprType.cpp b/bindings/Python/Generated/AST/TypeOfExprType.cpp
index a46a0d5e9..2587cbd31 100644
--- a/bindings/Python/Generated/AST/TypeOfExprType.cpp
+++ b/bindings/Python/Generated/AST/TypeOfExprType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeOfType.cpp b/bindings/Python/Generated/AST/TypeOfType.cpp
index 74af8d5d3..ab8510c3b 100644
--- a/bindings/Python/Generated/AST/TypeOfType.cpp
+++ b/bindings/Python/Generated/AST/TypeOfType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeTagForDatatypeAttr.cpp b/bindings/Python/Generated/AST/TypeTagForDatatypeAttr.cpp
index 0b3e99c3c..588616eda 100644
--- a/bindings/Python/Generated/AST/TypeTagForDatatypeAttr.cpp
+++ b/bindings/Python/Generated/AST/TypeTagForDatatypeAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -320,7 +319,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeTraitExpr.cpp b/bindings/Python/Generated/AST/TypeTraitExpr.cpp
index d3cbdead7..3d0d45cbd 100644
--- a/bindings/Python/Generated/AST/TypeTraitExpr.cpp
+++ b/bindings/Python/Generated/AST/TypeTraitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypeTraitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TypeTraitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypeTraitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TypeTraitExpr::from"),
+  },
   {
     "nth_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/TypeVisibilityAttr.cpp b/bindings/Python/Generated/AST/TypeVisibilityAttr.cpp
index 4e5db4f44..1336bb36b 100644
--- a/bindings/Python/Generated/AST/TypeVisibilityAttr.cpp
+++ b/bindings/Python/Generated/AST/TypeVisibilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypeWithKeyword.cpp b/bindings/Python/Generated/AST/TypeWithKeyword.cpp
index 02ebf63c6..1e49955a5 100644
--- a/bindings/Python/Generated/AST/TypeWithKeyword.cpp
+++ b/bindings/Python/Generated/AST/TypeWithKeyword.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -265,7 +264,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypedefDecl.cpp b/bindings/Python/Generated/AST/TypedefDecl.cpp
index 2fcb6af92..674f1295d 100644
--- a/bindings/Python/Generated/AST/TypedefDecl.cpp
+++ b/bindings/Python/Generated/AST/TypedefDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypedefDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TypedefDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypedefDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TypedefDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TypedefNameDecl.cpp b/bindings/Python/Generated/AST/TypedefNameDecl.cpp
index 18471e64e..308ce02ff 100644
--- a/bindings/Python/Generated/AST/TypedefNameDecl.cpp
+++ b/bindings/Python/Generated/AST/TypedefNameDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -306,18 +305,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::TypedefNameDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TypedefNameDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TypedefNameDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -343,7 +380,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -366,52 +403,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypedefNameDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TypedefNameDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TypedefNameDecl::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/TypedefType.cpp b/bindings/Python/Generated/AST/TypedefType.cpp
index 3e7291844..f1340671e 100644
--- a/bindings/Python/Generated/AST/TypedefType.cpp
+++ b/bindings/Python/Generated/AST/TypedefType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -294,7 +293,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/TypoExpr.cpp b/bindings/Python/Generated/AST/TypoExpr.cpp
index cf3ceb362..a8691005c 100644
--- a/bindings/Python/Generated/AST/TypoExpr.cpp
+++ b/bindings/Python/Generated/AST/TypoExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -227,67 +226,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypoExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::TypoExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -351,6 +289,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::TypoExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::TypoExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UPtrAttr.cpp b/bindings/Python/Generated/AST/UPtrAttr.cpp
index afbe91b72..4d32334de 100644
--- a/bindings/Python/Generated/AST/UPtrAttr.cpp
+++ b/bindings/Python/Generated/AST/UPtrAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UnaryExprOrTypeTraitExpr.cpp b/bindings/Python/Generated/AST/UnaryExprOrTypeTraitExpr.cpp
index 219c994a7..313d384cf 100644
--- a/bindings/Python/Generated/AST/UnaryExprOrTypeTraitExpr.cpp
+++ b/bindings/Python/Generated/AST/UnaryExprOrTypeTraitExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnaryExprOrTypeTraitExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UnaryExprOrTypeTraitExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnaryExprOrTypeTraitExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UnaryExprOrTypeTraitExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UnaryOperator.cpp b/bindings/Python/Generated/AST/UnaryOperator.cpp
index 4318e91e1..7a63b11a4 100644
--- a/bindings/Python/Generated/AST/UnaryOperator.cpp
+++ b/bindings/Python/Generated/AST/UnaryOperator.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -337,67 +336,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnaryOperator::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UnaryOperator::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -461,6 +399,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnaryOperator::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UnaryOperator::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UnaryTransformType.cpp b/bindings/Python/Generated/AST/UnaryTransformType.cpp
index b732ea20c..f64f600f2 100644
--- a/bindings/Python/Generated/AST/UnaryTransformType.cpp
+++ b/bindings/Python/Generated/AST/UnaryTransformType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -304,7 +303,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UnavailableAttr.cpp b/bindings/Python/Generated/AST/UnavailableAttr.cpp
index 22194fa4b..f1ee62170 100644
--- a/bindings/Python/Generated/AST/UnavailableAttr.cpp
+++ b/bindings/Python/Generated/AST/UnavailableAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UninitializedAttr.cpp b/bindings/Python/Generated/AST/UninitializedAttr.cpp
index 9398eff67..4fdd4ecbb 100644
--- a/bindings/Python/Generated/AST/UninitializedAttr.cpp
+++ b/bindings/Python/Generated/AST/UninitializedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UnlikelyAttr.cpp b/bindings/Python/Generated/AST/UnlikelyAttr.cpp
index 09f4ad7b1..8be0d6a00 100644
--- a/bindings/Python/Generated/AST/UnlikelyAttr.cpp
+++ b/bindings/Python/Generated/AST/UnlikelyAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UnnamedGlobalConstantDecl.cpp b/bindings/Python/Generated/AST/UnnamedGlobalConstantDecl.cpp
index f7e6cb961..437a1fd3b 100644
--- a/bindings/Python/Generated/AST/UnnamedGlobalConstantDecl.cpp
+++ b/bindings/Python/Generated/AST/UnnamedGlobalConstantDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnnamedGlobalConstantDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UnnamedGlobalConstantDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnnamedGlobalConstantDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UnnamedGlobalConstantDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UnresolvedLookupExpr.cpp b/bindings/Python/Generated/AST/UnresolvedLookupExpr.cpp
index edf39b99d..0b4666706 100644
--- a/bindings/Python/Generated/AST/UnresolvedLookupExpr.cpp
+++ b/bindings/Python/Generated/AST/UnresolvedLookupExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -247,67 +246,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedLookupExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UnresolvedLookupExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -371,6 +309,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedLookupExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UnresolvedLookupExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UnresolvedMemberExpr.cpp b/bindings/Python/Generated/AST/UnresolvedMemberExpr.cpp
index c1c079367..61c80f84c 100644
--- a/bindings/Python/Generated/AST/UnresolvedMemberExpr.cpp
+++ b/bindings/Python/Generated/AST/UnresolvedMemberExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedMemberExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UnresolvedMemberExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedMemberExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UnresolvedMemberExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UnresolvedUsingIfExistsDecl.cpp b/bindings/Python/Generated/AST/UnresolvedUsingIfExistsDecl.cpp
index 1fa4bee99..3bef961d8 100644
--- a/bindings/Python/Generated/AST/UnresolvedUsingIfExistsDecl.cpp
+++ b/bindings/Python/Generated/AST/UnresolvedUsingIfExistsDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedUsingIfExistsDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UnresolvedUsingIfExistsDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedUsingIfExistsDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UnresolvedUsingIfExistsDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UnresolvedUsingType.cpp b/bindings/Python/Generated/AST/UnresolvedUsingType.cpp
index 24f3b8be9..ecd1f4a4f 100644
--- a/bindings/Python/Generated/AST/UnresolvedUsingType.cpp
+++ b/bindings/Python/Generated/AST/UnresolvedUsingType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -284,7 +283,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UnresolvedUsingTypenameDecl.cpp b/bindings/Python/Generated/AST/UnresolvedUsingTypenameDecl.cpp
index 99525bb49..f01e91b4a 100644
--- a/bindings/Python/Generated/AST/UnresolvedUsingTypenameDecl.cpp
+++ b/bindings/Python/Generated/AST/UnresolvedUsingTypenameDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedUsingTypenameDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UnresolvedUsingTypenameDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedUsingTypenameDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UnresolvedUsingTypenameDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UnresolvedUsingValueDecl.cpp b/bindings/Python/Generated/AST/UnresolvedUsingValueDecl.cpp
index 636e30666..26ca8d2f0 100644
--- a/bindings/Python/Generated/AST/UnresolvedUsingValueDecl.cpp
+++ b/bindings/Python/Generated/AST/UnresolvedUsingValueDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedUsingValueDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UnresolvedUsingValueDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UnresolvedUsingValueDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UnresolvedUsingValueDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UnsafeBufferUsageAttr.cpp b/bindings/Python/Generated/AST/UnsafeBufferUsageAttr.cpp
index ee3747e5e..e3bb0dada 100644
--- a/bindings/Python/Generated/AST/UnsafeBufferUsageAttr.cpp
+++ b/bindings/Python/Generated/AST/UnsafeBufferUsageAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UnusedAttr.cpp b/bindings/Python/Generated/AST/UnusedAttr.cpp
index 1b32159b5..751869246 100644
--- a/bindings/Python/Generated/AST/UnusedAttr.cpp
+++ b/bindings/Python/Generated/AST/UnusedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UseHandleAttr.cpp b/bindings/Python/Generated/AST/UseHandleAttr.cpp
index 5c0f6e736..c2eae0e0f 100644
--- a/bindings/Python/Generated/AST/UseHandleAttr.cpp
+++ b/bindings/Python/Generated/AST/UseHandleAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UsedAttr.cpp b/bindings/Python/Generated/AST/UsedAttr.cpp
index f15ad53a7..aa90b3a1e 100644
--- a/bindings/Python/Generated/AST/UsedAttr.cpp
+++ b/bindings/Python/Generated/AST/UsedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UserDefinedLiteral.cpp b/bindings/Python/Generated/AST/UserDefinedLiteral.cpp
index 705d63ecb..cbdca6605 100644
--- a/bindings/Python/Generated/AST/UserDefinedLiteral.cpp
+++ b/bindings/Python/Generated/AST/UserDefinedLiteral.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -257,67 +256,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UserDefinedLiteral::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UserDefinedLiteral::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -381,6 +319,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UserDefinedLiteral::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UserDefinedLiteral::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UsingDecl.cpp b/bindings/Python/Generated/AST/UsingDecl.cpp
index ea4cd5ec8..55e9acb46 100644
--- a/bindings/Python/Generated/AST/UsingDecl.cpp
+++ b/bindings/Python/Generated/AST/UsingDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -287,67 +286,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UsingDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -411,6 +349,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UsingDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UsingDirectiveDecl.cpp b/bindings/Python/Generated/AST/UsingDirectiveDecl.cpp
index 2042ea357..f22a2bd97 100644
--- a/bindings/Python/Generated/AST/UsingDirectiveDecl.cpp
+++ b/bindings/Python/Generated/AST/UsingDirectiveDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingDirectiveDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UsingDirectiveDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingDirectiveDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UsingDirectiveDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UsingEnumDecl.cpp b/bindings/Python/Generated/AST/UsingEnumDecl.cpp
index 00b93db0a..39945ec2a 100644
--- a/bindings/Python/Generated/AST/UsingEnumDecl.cpp
+++ b/bindings/Python/Generated/AST/UsingEnumDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -297,67 +296,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingEnumDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UsingEnumDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -421,6 +359,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingEnumDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UsingEnumDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UsingIfExistsAttr.cpp b/bindings/Python/Generated/AST/UsingIfExistsAttr.cpp
index 8be164f27..b17253919 100644
--- a/bindings/Python/Generated/AST/UsingIfExistsAttr.cpp
+++ b/bindings/Python/Generated/AST/UsingIfExistsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UsingPackDecl.cpp b/bindings/Python/Generated/AST/UsingPackDecl.cpp
index 84d6755cb..5c4f683a5 100644
--- a/bindings/Python/Generated/AST/UsingPackDecl.cpp
+++ b/bindings/Python/Generated/AST/UsingPackDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingPackDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UsingPackDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingPackDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UsingPackDecl::from"),
+  },
   {
     "nth_expansion",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/UsingShadowDecl.cpp b/bindings/Python/Generated/AST/UsingShadowDecl.cpp
index 26c8026b1..f1e5a3209 100644
--- a/bindings/Python/Generated/AST/UsingShadowDecl.cpp
+++ b/bindings/Python/Generated/AST/UsingShadowDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -291,67 +290,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingShadowDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::UsingShadowDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -415,6 +353,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::UsingShadowDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::UsingShadowDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/UsingType.cpp b/bindings/Python/Generated/AST/UsingType.cpp
index 1341c0f6c..b119d2443 100644
--- a/bindings/Python/Generated/AST/UsingType.cpp
+++ b/bindings/Python/Generated/AST/UsingType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -304,7 +303,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/UuidAttr.cpp b/bindings/Python/Generated/AST/UuidAttr.cpp
index f9e928ea7..cb98d79c0 100644
--- a/bindings/Python/Generated/AST/UuidAttr.cpp
+++ b/bindings/Python/Generated/AST/UuidAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/VAArgExpr.cpp b/bindings/Python/Generated/AST/VAArgExpr.cpp
index 2371cef47..363dd19d2 100644
--- a/bindings/Python/Generated/AST/VAArgExpr.cpp
+++ b/bindings/Python/Generated/AST/VAArgExpr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VAArgExpr::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::VAArgExpr::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VAArgExpr::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::VAArgExpr::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ValueDecl.cpp b/bindings/Python/Generated/AST/ValueDecl.cpp
index fc057b876..b551e7d28 100644
--- a/bindings/Python/Generated/AST/ValueDecl.cpp
+++ b/bindings/Python/Generated/AST/ValueDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -402,18 +401,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::ValueDecl::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ValueDecl::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ValueDecl::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
             if (!arg_0.has_value()) {
@@ -439,7 +476,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -462,52 +499,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ValueDecl::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ValueDecl::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ValueDecl::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/ValueStmt.cpp b/bindings/Python/Generated/AST/ValueStmt.cpp
index ef44b3f4c..f2a670f5c 100644
--- a/bindings/Python/Generated/AST/ValueStmt.cpp
+++ b/bindings/Python/Generated/AST/ValueStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -738,18 +737,56 @@ static PyMethodDef gMethods[] = {
     PyDoc_STR("Wrapper for mx::ValueStmt::containing"),
   },
   {
-    "FROM",
+    "by_id",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 2) {
+            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
+            if (!arg_1.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'by_id'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ValueStmt::by_id"),
+  },
+  {
+    "from_base",
     reinterpret_cast<PyCFunction>(
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
 
-            return ::mx::to_python(T::from(arg_0.value()));
+            return ::mx::to_python(T::from_base(arg_0.value()));
           }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'from_base'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::ValueStmt::from_base"),
+  },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
             if (!arg_0.has_value()) {
@@ -775,7 +812,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -798,52 +835,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::ValueStmt::from"),
   },
-  {
-    "by_id",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Index>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<EntityId>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::by_id(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'by_id'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ValueStmt::by_id"),
-  },
-  {
-    "from_base",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from_base(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'from_base'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ValueStmt::from_base"),
-  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/VarDecl.cpp b/bindings/Python/Generated/AST/VarDecl.cpp
index f3d355126..c1e0d6d19 100644
--- a/bindings/Python/Generated/AST/VarDecl.cpp
+++ b/bindings/Python/Generated/AST/VarDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -711,67 +710,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VarDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::VarDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -835,6 +773,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VarDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::VarDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/VarTemplateDecl.cpp b/bindings/Python/Generated/AST/VarTemplateDecl.cpp
index b254b005f..f85cfd8d9 100644
--- a/bindings/Python/Generated/AST/VarTemplateDecl.cpp
+++ b/bindings/Python/Generated/AST/VarTemplateDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -267,67 +266,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VarTemplateDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::VarTemplateDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -391,6 +329,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VarTemplateDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::VarTemplateDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/VarTemplatePartialSpecializationDecl.cpp b/bindings/Python/Generated/AST/VarTemplatePartialSpecializationDecl.cpp
index 9f3cc14bf..924595f71 100644
--- a/bindings/Python/Generated/AST/VarTemplatePartialSpecializationDecl.cpp
+++ b/bindings/Python/Generated/AST/VarTemplatePartialSpecializationDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -277,67 +276,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VarTemplatePartialSpecializationDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::VarTemplatePartialSpecializationDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -401,6 +339,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VarTemplatePartialSpecializationDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::VarTemplatePartialSpecializationDecl::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/VarTemplateSpecializationDecl.cpp b/bindings/Python/Generated/AST/VarTemplateSpecializationDecl.cpp
index 839d98e1b..12b514eab 100644
--- a/bindings/Python/Generated/AST/VarTemplateSpecializationDecl.cpp
+++ b/bindings/Python/Generated/AST/VarTemplateSpecializationDecl.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -351,67 +350,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VarTemplateSpecializationDecl::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::VarTemplateSpecializationDecl::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -475,6 +413,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::VarTemplateSpecializationDecl::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Decl>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::VarTemplateSpecializationDecl::from"),
+  },
   {
     "nth_template_argument",
     reinterpret_cast<PyCFunction>(
diff --git a/bindings/Python/Generated/AST/VariableArrayType.cpp b/bindings/Python/Generated/AST/VariableArrayType.cpp
index cc8036512..f5af80730 100644
--- a/bindings/Python/Generated/AST/VariableArrayType.cpp
+++ b/bindings/Python/Generated/AST/VariableArrayType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -314,7 +313,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/VecReturnAttr.cpp b/bindings/Python/Generated/AST/VecReturnAttr.cpp
index 9ec6e64bd..34be6b5fc 100644
--- a/bindings/Python/Generated/AST/VecReturnAttr.cpp
+++ b/bindings/Python/Generated/AST/VecReturnAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/VecTypeHintAttr.cpp b/bindings/Python/Generated/AST/VecTypeHintAttr.cpp
index c6277af61..c18563fc2 100644
--- a/bindings/Python/Generated/AST/VecTypeHintAttr.cpp
+++ b/bindings/Python/Generated/AST/VecTypeHintAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/VectorCallAttr.cpp b/bindings/Python/Generated/AST/VectorCallAttr.cpp
index c3935c4f9..f0efad797 100644
--- a/bindings/Python/Generated/AST/VectorCallAttr.cpp
+++ b/bindings/Python/Generated/AST/VectorCallAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/VectorType.cpp b/bindings/Python/Generated/AST/VectorType.cpp
index bee7c58c5..e4396aeba 100644
--- a/bindings/Python/Generated/AST/VectorType.cpp
+++ b/bindings/Python/Generated/AST/VectorType.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -298,7 +297,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/VisibilityAttr.cpp b/bindings/Python/Generated/AST/VisibilityAttr.cpp
index 6cda72679..da37dec43 100644
--- a/bindings/Python/Generated/AST/VisibilityAttr.cpp
+++ b/bindings/Python/Generated/AST/VisibilityAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WarnUnusedAttr.cpp b/bindings/Python/Generated/AST/WarnUnusedAttr.cpp
index 4e3a6d61b..e5dc68e5b 100644
--- a/bindings/Python/Generated/AST/WarnUnusedAttr.cpp
+++ b/bindings/Python/Generated/AST/WarnUnusedAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WarnUnusedResultAttr.cpp b/bindings/Python/Generated/AST/WarnUnusedResultAttr.cpp
index 5d7b927a6..27f765e40 100644
--- a/bindings/Python/Generated/AST/WarnUnusedResultAttr.cpp
+++ b/bindings/Python/Generated/AST/WarnUnusedResultAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -320,7 +319,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WeakAttr.cpp b/bindings/Python/Generated/AST/WeakAttr.cpp
index f32013a7b..3c23e9b47 100644
--- a/bindings/Python/Generated/AST/WeakAttr.cpp
+++ b/bindings/Python/Generated/AST/WeakAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WeakImportAttr.cpp b/bindings/Python/Generated/AST/WeakImportAttr.cpp
index ffd298b09..59435cd8d 100644
--- a/bindings/Python/Generated/AST/WeakImportAttr.cpp
+++ b/bindings/Python/Generated/AST/WeakImportAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WeakRefAttr.cpp b/bindings/Python/Generated/AST/WeakRefAttr.cpp
index 3910aa5a7..241f98181 100644
--- a/bindings/Python/Generated/AST/WeakRefAttr.cpp
+++ b/bindings/Python/Generated/AST/WeakRefAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WebAssemblyExportNameAttr.cpp b/bindings/Python/Generated/AST/WebAssemblyExportNameAttr.cpp
index 2aefd0b42..c62fcacee 100644
--- a/bindings/Python/Generated/AST/WebAssemblyExportNameAttr.cpp
+++ b/bindings/Python/Generated/AST/WebAssemblyExportNameAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WebAssemblyFuncrefAttr.cpp b/bindings/Python/Generated/AST/WebAssemblyFuncrefAttr.cpp
index 7c7413dd4..25ecbc0dd 100644
--- a/bindings/Python/Generated/AST/WebAssemblyFuncrefAttr.cpp
+++ b/bindings/Python/Generated/AST/WebAssemblyFuncrefAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WebAssemblyImportModuleAttr.cpp b/bindings/Python/Generated/AST/WebAssemblyImportModuleAttr.cpp
index 161399852..49d64ea1e 100644
--- a/bindings/Python/Generated/AST/WebAssemblyImportModuleAttr.cpp
+++ b/bindings/Python/Generated/AST/WebAssemblyImportModuleAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WebAssemblyImportNameAttr.cpp b/bindings/Python/Generated/AST/WebAssemblyImportNameAttr.cpp
index 424a34e7b..6507e76d2 100644
--- a/bindings/Python/Generated/AST/WebAssemblyImportNameAttr.cpp
+++ b/bindings/Python/Generated/AST/WebAssemblyImportNameAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -300,7 +299,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/WhileStmt.cpp b/bindings/Python/Generated/AST/WhileStmt.cpp
index 416d59a85..a9c4d2586 100644
--- a/bindings/Python/Generated/AST/WhileStmt.cpp
+++ b/bindings/Python/Generated/AST/WhileStmt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -307,67 +306,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::WhileStmt::containing"),
   },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::WhileStmt::from"),
-  },
   {
     "static_kind",
     reinterpret_cast<PyCFunction>(
@@ -431,6 +369,59 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL | METH_STATIC,
     PyDoc_STR("Wrapper for mx::WhileStmt::from_base"),
   },
+  {
+    "FROM",
+    reinterpret_cast<PyCFunction>(
+        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
+          (void) args;
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::optional<mx::Stmt>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::Reference>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+          while (num_args == 1) {
+            auto arg_0 = ::mx::from_python<mx::TokenContext>(args[0]);
+            if (!arg_0.has_value()) {
+              break;
+            }
+
+            return ::mx::to_python(T::from(arg_0.value()));
+          }
+
+          PyErrorStreamer(PyExc_TypeError)
+              << "Invalid arguments passed to 'FROM'";
+          return nullptr;
+        }),
+    METH_FASTCALL | METH_STATIC,
+    PyDoc_STR("Wrapper for mx::WhileStmt::from"),
+  },
   {}  // Sentinel.
 };
 }  // namespace
diff --git a/bindings/Python/Generated/AST/WorkGroupSizeHintAttr.cpp b/bindings/Python/Generated/AST/WorkGroupSizeHintAttr.cpp
index cba18d7b7..4e35f2810 100644
--- a/bindings/Python/Generated/AST/WorkGroupSizeHintAttr.cpp
+++ b/bindings/Python/Generated/AST/WorkGroupSizeHintAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/X86ForceAlignArgPointerAttr.cpp b/bindings/Python/Generated/AST/X86ForceAlignArgPointerAttr.cpp
index a8836ceb3..9e120e5d7 100644
--- a/bindings/Python/Generated/AST/X86ForceAlignArgPointerAttr.cpp
+++ b/bindings/Python/Generated/AST/X86ForceAlignArgPointerAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -280,7 +279,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/XRayInstrumentAttr.cpp b/bindings/Python/Generated/AST/XRayInstrumentAttr.cpp
index bd0bde3ec..3b6c7e8c2 100644
--- a/bindings/Python/Generated/AST/XRayInstrumentAttr.cpp
+++ b/bindings/Python/Generated/AST/XRayInstrumentAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -310,7 +309,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/XRayLogArgsAttr.cpp b/bindings/Python/Generated/AST/XRayLogArgsAttr.cpp
index 4ab755616..844a8178f 100644
--- a/bindings/Python/Generated/AST/XRayLogArgsAttr.cpp
+++ b/bindings/Python/Generated/AST/XRayLogArgsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/AST/ZeroCallUsedRegsAttr.cpp b/bindings/Python/Generated/AST/ZeroCallUsedRegsAttr.cpp
index 77192bb77..f32073d8b 100644
--- a/bindings/Python/Generated/AST/ZeroCallUsedRegsAttr.cpp
+++ b/bindings/Python/Generated/AST/ZeroCallUsedRegsAttr.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -290,7 +289,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Bindings.cpp b/bindings/Python/Generated/Bindings.cpp
index 769cad11e..3ff27cc3d 100644
--- a/bindings/Python/Generated/Bindings.cpp
+++ b/bindings/Python/Generated/Bindings.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 #include <multiplier/Reference.h>
 
@@ -23,16333 +22,10907 @@ template MX_EXPORT SharedPyObject *mx::to_python<std::vector<mx::Fragment>>(std:
 
 // The rest are auto-generated...
 
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Operation>::Type>
-from_python<mx::ir::Operation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StmtLikelihood>::Type>
-from_python<mx::StmtLikelihood>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StmtKind>::Type>
-from_python<mx::StmtKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DefaultVisiblityExportMapping>::Type>
-from_python<mx::DefaultVisiblityExportMapping>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Decl>>::Type>
-from_python<std::optional<mx::Decl>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SuppressAttrSpelling>::Type>
-from_python<mx::SuppressAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DesignatorKind>::Type>
-from_python<mx::DesignatorKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Attr>>::Type>
-from_python<std::optional<mx::Attr>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Stmt>>::Type>
-from_python<std::optional<mx::Stmt>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnosticLevelMask>::Type>
-from_python<mx::DiagnosticLevelMask>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncAttrKind>::Type>
-from_python<mx::SwiftAsyncAttrKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ElaboratedTypeKeyword>::Type>
-from_python<mx::ElaboratedTypeKeyword>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeTrait>::Type>
-from_python<mx::TypeTrait>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncAttrSpelling>::Type>
-from_python<mx::SwiftAsyncAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DbgValueOp>::Type>
-from_python<mx::ir::llvm::DbgValueOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EscapeChar>::Type>
-from_python<mx::EscapeChar>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncCallAttrSpelling>::Type>
-from_python<mx::SwiftAsyncCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryExprOrTypeTrait>::Type>
-from_python<mx::UnaryExprOrTypeTrait>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Type>>::Type>
-from_python<std::optional<mx::Type>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DIExpressionAttr>::Type>
-from_python<mx::ir::llvm::DIExpressionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncContextAttrSpelling>::Type>
-from_python<mx::SwiftAsyncContextAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryOperatorKind>::Type>
-from_python<mx::UnaryOperatorKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncErrorAttrConventionKind>::Type>
-from_python<mx::SwiftAsyncErrorAttrConventionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncErrorAttrSpelling>::Type>
-from_python<mx::SwiftAsyncErrorAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CondOp>::Type>
-from_python<mx::ir::hl::CondOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftCallAttrSpelling>::Type>
-from_python<mx::SwiftCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CompoundLiteralOp>::Type>
-from_python<mx::ir::hl::CompoundLiteralOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExceptionHandlingKind>::Type>
-from_python<mx::ExceptionHandlingKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::APValueKind>::Type>
-from_python<mx::APValueKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DINullTypeAttr>::Type>
-from_python<mx::ir::llvm::DINullTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftContextAttrSpelling>::Type>
-from_python<mx::SwiftContextAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VectorKind>::Type>
-from_python<mx::VectorKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftErrorAttrConventionKind>::Type>
-from_python<mx::SwiftErrorAttrConventionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftErrorResultAttrSpelling>::Type>
-from_python<mx::SwiftErrorResultAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExceptionSpecificationType>::Type>
-from_python<mx::ExceptionSpecificationType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftIndirectResultAttrSpelling>::Type>
-from_python<mx::SwiftIndirectResultAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExcessPrecisionKind>::Type>
-from_python<mx::ExcessPrecisionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DebugTrapOp>::Type>
-from_python<mx::ir::llvm::DebugTrapOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftNewTypeAttrNewtypeKind>::Type>
-from_python<mx::SwiftNewTypeAttrNewtypeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DIBasicTypeAttr>::Type>
-from_python<mx::ir::llvm::DIBasicTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::StoreOp>::Type>
-from_python<mx::ir::llvm::StoreOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftNewTypeAttrSpelling>::Type>
-from_python<mx::SwiftNewTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Visibility>::Type>
-from_python<mx::Visibility>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SysVABIAttrSpelling>::Type>
-from_python<mx::SysVABIAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ShuffleVectorOp>::Type>
-from_python<mx::ir::llvm::ShuffleVectorOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExplicitSpecKind>::Type>
-from_python<mx::ExplicitSpecKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TLSModelAttrSpelling>::Type>
-from_python<mx::TLSModelAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::EhTypeidForOp>::Type>
-from_python<mx::ir::llvm::EhTypeidForOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprDependence>::Type>
-from_python<mx::ExprDependence>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetAttrSpelling>::Type>
-from_python<mx::TargetAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprObjectKind>::Type>
-from_python<mx::ExprObjectKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetClonesAttrSpelling>::Type>
-from_python<mx::TargetClonesAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprOffsets>::Type>
-from_python<mx::ExprOffsets>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetVersionAttrSpelling>::Type>
-from_python<mx::TargetVersionAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityForcedKinds>::Type>
-from_python<mx::VisibilityForcedKinds>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::Exp2Op>::Type>
-from_python<mx::ir::llvm::Exp2Op>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateArgumentKind>::Type>
-from_python<mx::TemplateArgumentKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityFromDLLStorageClassKinds>::Type>
-from_python<mx::VisibilityFromDLLStorageClassKinds>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TestTypestateAttrConsumedState>::Type>
-from_python<mx::TestTypestateAttrConsumedState>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AttributeSyntax>::Type>
-from_python<mx::AttributeSyntax>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TestTypestateAttrSpelling>::Type>
-from_python<mx::TestTypestateAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DICompileUnitAttr>::Type>
-from_python<mx::ir::llvm::DICompileUnitAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclCategory>::Type>
-from_python<mx::DeclCategory>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprValueKind>::Type>
-from_python<mx::ExprValueKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Expr>::Type>
-from_python<mx::Expr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExpressionTrait>::Type>
-from_python<mx::ExpressionTrait>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Macro>>::Type>
-from_python<std::optional<mx::Macro>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ValueStmt>::Type>
-from_python<mx::ValueStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SubOp>::Type>
-from_python<mx::ir::llvm::SubOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExtKind>::Type>
-from_python<mx::ExtKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CondYieldOp>::Type>
-from_python<mx::ir::hl::CondYieldOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ThisCallAttrSpelling>::Type>
-from_python<mx::ThisCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PseudoKind>::Type>
-from_python<mx::PseudoKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TransparentUnionAttrSpelling>::Type>
-from_python<mx::TransparentUnionAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDispatchDirective>::Type>
-from_python<mx::OMPDispatchDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TrivialABIAttrSpelling>::Type>
-from_python<mx::TrivialABIAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExtendArgsKind>::Type>
-from_python<mx::ExtendArgsKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TryAcquireCapabilityAttrSpelling>::Type>
-from_python<mx::TryAcquireCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ExpOp>::Type>
-from_python<mx::ir::llvm::ExpOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeScalarTypeKind>::Type>
-from_python<mx::TypeScalarTypeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FPEvalMethodKind>::Type>
-from_python<mx::FPEvalMethodKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroParameter>::Type>
-from_python<mx::MacroParameter>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DICompositeTypeAttr>::Type>
-from_python<mx::ir::llvm::DICompositeTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeKind>::Type>
-from_python<mx::TypeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EntityCategory>::Type>
-from_python<mx::EntityCategory>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXFoldExpr>::Type>
-from_python<mx::CXXFoldExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeTagForDatatypeAttrSpelling>::Type>
-from_python<mx::TypeTagForDatatypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FPExceptionModeKind>::Type>
-from_python<mx::FPExceptionModeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FPModeKind>::Type>
-from_python<mx::FPModeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeVisibilityAttrSpelling>::Type>
-from_python<mx::TypeVisibilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ConstantOp>::Type>
-from_python<mx::ir::hl::ConstantOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UDivOp>::Type>
-from_python<mx::ir::llvm::UDivOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Flags>::Type>
-from_python<mx::Flags>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GC>::Type>
-from_python<mx::GC>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DIDerivedTypeAttr>::Type>
-from_python<mx::ir::llvm::DIDerivedTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignValueAttr>::Type>
-from_python<mx::AlignValueAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GPUDefaultStreamKind>::Type>
-from_python<mx::GPUDefaultStreamKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<EntityId>::Type>
-from_python<EntityId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GCMode>::Type>
-from_python<mx::GCMode>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeVisibilityAttrVisibilityType>::Type>
-from_python<mx::TypeVisibilityAttrVisibilityType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryTransformTypeUTTKind>::Type>
-from_python<mx::UnaryTransformTypeUTTKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Decl>::Type>
-from_python<mx::Decl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnavailableAttrImplicitReason>::Type>
-from_python<mx::UnavailableAttrImplicitReason>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ContinueOp>::Type>
-from_python<mx::ir::hl::ContinueOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GVALinkage>::Type>
-from_python<mx::GVALinkage>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnavailableAttrSpelling>::Type>
-from_python<mx::UnavailableAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GetBuiltinTypeError>::Type>
-from_python<mx::GetBuiltinTypeError>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PseudoObjectExpr>::Type>
-from_python<mx::PseudoObjectExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DIFileAttr>::Type>
-from_python<mx::ir::llvm::DIFileAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UninitializedAttrSpelling>::Type>
-from_python<mx::UninitializedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLLangStd>::Type>
-from_python<mx::HLSLLangStd>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::TruncOp>::Type>
-from_python<mx::ir::llvm::TruncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CxxBaseSpecifierOp>::Type>
-from_python<mx::ir::hl::CxxBaseSpecifierOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ID>::Type>
-from_python<mx::ID>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnlikelyAttrSpelling>::Type>
-from_python<mx::UnlikelyAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SwitchOp>::Type>
-from_python<mx::ir::llvm::SwitchOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ExpectOp>::Type>
-from_python<mx::ir::llvm::ExpectOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnsafeBufferUsageAttrSpelling>::Type>
-from_python<mx::UnsafeBufferUsageAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Stmt>::Type>
-from_python<mx::Stmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnusedAttrSpelling>::Type>
-from_python<mx::UnusedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IdentifierInfoFlag>::Type>
-from_python<mx::IdentifierInfoFlag>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UseHandleAttrSpelling>::Type>
-from_python<mx::UseHandleAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DIGlobalVariableExpressionAttr>::Type>
-from_python<mx::ir::llvm::DIGlobalVariableExpressionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsedAttrSpelling>::Type>
-from_python<mx::UsedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IfStatementKind>::Type>
-from_python<mx::IfStatementKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UserDefinedLiteralLiteralOperatorKind>::Type>
-from_python<mx::UserDefinedLiteralLiteralOperatorKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitParamKind>::Type>
-from_python<mx::ImplicitParamKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExceptionAttr>::Type>
-from_python<mx::ObjCExceptionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingIfExistsAttrSpelling>::Type>
-from_python<mx::UsingIfExistsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InClassInitStyle>::Type>
-from_python<mx::InClassInitStyle>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UuidAttrSpelling>::Type>
-from_python<mx::UuidAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InheritedDesignatedInitializersState>::Type>
-from_python<mx::InheritedDesignatedInitializersState>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FAbsOp>::Type>
-from_python<mx::ir::llvm::FAbsOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DIGlobalVariableAttr>::Type>
-from_python<mx::ir::llvm::DIGlobalVariableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ExpectWithProbabilityOp>::Type>
-from_python<mx::ir::llvm::ExpectWithProbabilityOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InitStorageKind>::Type>
-from_python<mx::InitStorageKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VarDeclDefinitionKind>::Type>
-from_python<mx::VarDeclDefinitionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InlineVariableDefinitionKind>::Type>
-from_python<mx::InlineVariableDefinitionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CxxStructDeclOp>::Type>
-from_python<mx::ir::hl::CxxStructDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VarDeclInitializationStyle>::Type>
-from_python<mx::VarDeclInitializationStyle>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VarDeclTLSKind>::Type>
-from_python<mx::VarDeclTLSKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InterestingIdentifierKind>::Type>
-from_python<mx::InterestingIdentifierKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VecReturnAttrSpelling>::Type>
-from_python<mx::VecReturnAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Index>::Type>
-from_python<mx::Index>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SuppressAttr>::Type>
-from_python<mx::SuppressAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCCategoryDecl>::Type>
-from_python<mx::ObjCCategoryDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VectorCallAttrSpelling>::Type>
-from_python<mx::VectorCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LambdaCaptureDefault>::Type>
-from_python<mx::LambdaCaptureDefault>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaMacroDirective>::Type>
-from_python<mx::PragmaMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FCeilOp>::Type>
-from_python<mx::ir::llvm::FCeilOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Kinds>::Type>
-from_python<mx::Kinds>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityAttrSpelling>::Type>
-from_python<mx::VisibilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityAttrVisibilityType>::Type>
-from_python<mx::VisibilityAttrVisibilityType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DILexicalBlockAttr>::Type>
-from_python<mx::ir::llvm::DILexicalBlockAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WarnUnusedAttrSpelling>::Type>
-from_python<mx::WarnUnusedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WarnUnusedResultAttrSpelling>::Type>
-from_python<mx::WarnUnusedResultAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LambdaCaptureKind>::Type>
-from_python<mx::LambdaCaptureKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedStmt>::Type>
-from_python<mx::CapturedStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakAttrSpelling>::Type>
-from_python<mx::WeakAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DeclRefOp>::Type>
-from_python<mx::ir::hl::DeclRefOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LangAS>::Type>
-from_python<mx::LangAS>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::filesystem::path>::Type>
-from_python<std::filesystem::path>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakImportAttrSpelling>::Type>
-from_python<mx::WeakImportAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Compilation>::Type>
-from_python<mx::Compilation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakRefAttrSpelling>::Type>
-from_python<mx::WeakRefAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LangFeatures>::Type>
-from_python<mx::LangFeatures>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyExportNameAttrSpelling>::Type>
-from_python<mx::WebAssemblyExportNameAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyImportModuleAttrSpelling>::Type>
-from_python<mx::WebAssemblyImportModuleAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Fragment>::Type>
-from_python<mx::Fragment>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyImportNameAttrSpelling>::Type>
-from_python<mx::WebAssemblyImportNameAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86NoCallerSavedRegistersAttr>::Type>
-from_python<mx::AnyX86NoCallerSavedRegistersAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PipeType>::Type>
-from_python<mx::PipeType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Language>::Type>
-from_python<mx::Language>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::X86ForceAlignArgPointerAttrSpelling>::Type>
-from_python<mx::X86ForceAlignArgPointerAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DILexicalBlockFileAttr>::Type>
-from_python<mx::ir::llvm::DILexicalBlockFileAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoBuiltinAttr>::Type>
-from_python<mx::NoBuiltinAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::XRayInstrumentAttrSpelling>::Type>
-from_python<mx::XRayInstrumentAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LanguageLinkage>::Type>
-from_python<mx::LanguageLinkage>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::URemOp>::Type>
-from_python<mx::ir::llvm::URemOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::XRayLogArgsAttrSpelling>::Type>
-from_python<mx::XRayLogArgsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UIToFPOp>::Type>
-from_python<mx::ir::llvm::UIToFPOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ZeroCallUsedRegsAttrSpelling>::Type>
-from_python<mx::ZeroCallUsedRegsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DerefOp>::Type>
-from_python<mx::ir::hl::DerefOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind>::Type>
-from_python<mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DefaultOp>::Type>
-from_python<mx::ir::hl::DefaultOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeRelatedAttr>::Type>
-from_python<mx::ObjCBridgeRelatedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ASTDumpOutputFormat>::Type>
-from_python<mx::ASTDumpOutputFormat>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LaxVectorConversionKind>::Type>
-from_python<mx::LaxVectorConversionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DILocalVariableAttr>::Type>
-from_python<mx::ir::llvm::DILocalVariableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AccessSpecifier>::Type>
-from_python<mx::AccessSpecifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RegexQueryMatch>::Type>
-from_python<mx::RegexQueryMatch>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelForDirective>::Type>
-from_python<mx::OMPParallelForDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMasterTaskLoopDirective>::Type>
-from_python<mx::OMPMasterTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPBarrierDirective>::Type>
-from_python<mx::OMPBarrierDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDirective>::Type>
-from_python<mx::OMPTeamsDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AddrSpaceMapMangling>::Type>
-from_python<mx::AddrSpaceMapMangling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Token>::Type>
-from_python<mx::Token>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UndefOp>::Type>
-from_python<mx::ir::llvm::UndefOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FMAOp>::Type>
-from_python<mx::ir::llvm::FMAOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FFloorOp>::Type>
-from_python<mx::ir::llvm::FFloorOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignRequirementKind>::Type>
-from_python<mx::AlignRequirementKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Level>::Type>
-from_python<mx::Level>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AttributedStmt>::Type>
-from_python<mx::AttributedStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RequiresExprBodyDecl>::Type>
-from_python<mx::RequiresExprBodyDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMergeAttr>::Type>
-from_python<mx::NoMergeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CaseStmt>::Type>
-from_python<mx::CaseStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Linkage>::Type>
-from_python<mx::Linkage>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DISubprogramAttr>::Type>
-from_python<mx::ir::llvm::DISubprogramAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AltivecSrcCompatKind>::Type>
-from_python<mx::AltivecSrcCompatKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LinkageSpecLanguageIDs>::Type>
-from_python<mx::LinkageSpecLanguageIDs>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArgumentKind>::Type>
-from_python<mx::ArgumentKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArraySizeModifier>::Type>
-from_python<mx::ArraySizeModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenKind>::Type>
-from_python<mx::TokenKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXAddrspaceCastExpr>::Type>
-from_python<mx::CXXAddrspaceCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSInheritanceModel>::Type>
-from_python<mx::MSInheritanceModel>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXReinterpretCastExpr>::Type>
-from_python<mx::CXXReinterpretCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UndefineMacroDirective>::Type>
-from_python<mx::UndefineMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DIModuleAttr>::Type>
-from_python<mx::ir::llvm::DIModuleAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayTypeTrait>::Type>
-from_python<mx::ArrayTypeTrait>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAutoreleasePoolStmt>::Type>
-from_python<mx::ObjCAutoreleasePoolStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSVCMajorVersion>::Type>
-from_python<mx::MSVCMajorVersion>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParenType>::Type>
-from_python<mx::ParenType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtThrowStmt>::Type>
-from_python<mx::ObjCAtThrowStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AtomicScopeModelKind>::Type>
-from_python<mx::AtomicScopeModelKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInitExpr>::Type>
-from_python<mx::NoInitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSVtorDispMode>::Type>
-from_python<mx::MSVtorDispMode>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MatrixSubscriptExpr>::Type>
-from_python<mx::MatrixSubscriptExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DivFAssignOp>::Type>
-from_python<mx::ir::hl::DivFAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DivFOp>::Type>
-from_python<mx::ir::hl::DivFOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>::Type>
-from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MethodRefFlags>::Type>
-from_python<mx::MethodRefFlags>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86InterruptAttr>::Type>
-from_python<mx::AnyX86InterruptAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AutoTypeKeyword>::Type>
-from_python<mx::AutoTypeKeyword>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailabilityResult>::Type>
-from_python<mx::AvailabilityResult>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ModifiableType>::Type>
-from_python<mx::ModifiableType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ModeAttr>::Type>
-from_python<mx::ModeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MultiVersionKind>::Type>
-from_python<mx::MultiVersionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Attr>::Type>
-from_python<mx::Attr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NameKind>::Type>
-from_python<mx::NameKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DINamespaceAttr>::Type>
-from_python<mx::ir::llvm::DINamespaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BinaryOperatorKind>::Type>
-from_python<mx::BinaryOperatorKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NeedExtraManglingDecl>::Type>
-from_python<mx::NeedExtraManglingDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDistributeSimdDirective>::Type>
-from_python<mx::OMPDistributeSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDistributeParallelForDirective>::Type>
-from_python<mx::OMPDistributeParallelForDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeMutableAttr>::Type>
-from_python<mx::ObjCBridgeMutableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::XOrOp>::Type>
-from_python<mx::ir::llvm::XOrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConstructionKind>::Type>
-from_python<mx::CXXConstructionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FMulAddOp>::Type>
-from_python<mx::ir::llvm::FMulAddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NestedNameSpecifierDependence>::Type>
-from_python<mx::NestedNameSpecifierDependence>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UnreachableOp>::Type>
-from_python<mx::ir::llvm::UnreachableOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCCategoryImplDecl>::Type>
-from_python<mx::ObjCCategoryImplDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NonOdrUseReason>::Type>
-from_python<mx::NonOdrUseReason>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NonceObjCInterface>::Type>
-from_python<mx::NonceObjCInterface>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPLoopTransformationDirective>::Type>
-from_python<mx::OMPLoopTransformationDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedAttrId>::Type>
-from_python<PackedAttrId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTileDirective>::Type>
-from_python<mx::OMPTileDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroVAOpt>::Type>
-from_python<mx::MacroVAOpt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DISubrangeAttr>::Type>
-from_python<mx::ir::llvm::DISubrangeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedDecl>::Type>
-from_python<mx::CapturedDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NullabilityKind>::Type>
-from_python<mx::NullabilityKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareReductionInitKind>::Type>
-from_python<mx::OMPDeclareReductionInitKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeCastKind>::Type>
-from_python<mx::ObjCBridgeCastKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInlineAttr>::Type>
-from_python<mx::NoInlineAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCImplementationControl>::Type>
-from_python<mx::ObjCImplementationControl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLImportAttr>::Type>
-from_python<mx::DLLImportAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StandaloneDebugAttrSpelling>::Type>
-from_python<mx::StandaloneDebugAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DISubroutineTypeAttr>::Type>
-from_python<mx::ir::llvm::DISubroutineTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ZExtOp>::Type>
-from_python<mx::ir::llvm::ZExtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyRefExpr>::Type>
-from_python<mx::ObjCPropertyRefExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FShlOp>::Type>
-from_python<mx::ir::llvm::FShlOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FTruncOp>::Type>
-from_python<mx::ir::llvm::FTruncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::File>::Type>
-from_python<mx::File>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Bits>::Type>
-from_python<mx::Bits>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCInstanceTypeFamily>::Type>
-from_python<mx::ObjCInstanceTypeFamily>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNewInitializationStyle>::Type>
-from_python<mx::CXXNewInitializationStyle>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCLifetime>::Type>
-from_python<mx::ObjCLifetime>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPSimdDirective>::Type>
-from_python<mx::OMPSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMasterTaskLoopDirective>::Type>
-from_python<mx::OMPParallelMasterTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DivSOp>::Type>
-from_python<mx::ir::hl::DivSOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PackExpansionType>::Type>
-from_python<mx::PackExpansionType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodFamily>::Type>
-from_python<mx::ObjCMethodFamily>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCObjectType>::Type>
-from_python<mx::ObjCObjectType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DivSAssignOp>::Type>
-from_python<mx::ir::hl::DivSAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DILabelAttr>::Type>
-from_python<mx::ir::llvm::DILabelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CallingConv>::Type>
-from_python<mx::CallingConv>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyQueryKind>::Type>
-from_python<mx::ObjCPropertyQueryKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CanThrowResult>::Type>
-from_python<mx::CanThrowResult>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedRegionKind>::Type>
-from_python<mx::CapturedRegionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMasterTaskLoopSimdDirective>::Type>
-from_python<mx::OMPMasterTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OtherMacroDirective>::Type>
-from_python<mx::OtherMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCStringFormatFamily>::Type>
-from_python<mx::ObjCStringFormatFamily>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPAtomicDirective>::Type>
-from_python<mx::OMPAtomicDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMaskedTaskLoopSimdDirective>::Type>
-from_python<mx::OMPMaskedTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnalyzerNoReturnAttr>::Type>
-from_python<mx::AnalyzerNoReturnAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskyieldDirective>::Type>
-from_python<mx::OMPTaskyieldDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AllocSizeAttr>::Type>
-from_python<mx::AllocSizeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CastKind>::Type>
-from_python<mx::CastKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LoopHintAttr>::Type>
-from_python<mx::LoopHintAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InitSegAttr>::Type>
-from_python<mx::InitSegAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MemoryEffectsAttr>::Type>
-from_python<mx::ir::llvm::MemoryEffectsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CharacterLiteralKind>::Type>
-from_python<mx::CharacterLiteralKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSubstitutionContext>::Type>
-from_python<mx::ObjCSubstitutionContext>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCTypeParamVariance>::Type>
-from_python<mx::ObjCTypeParamVariance>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ClangABI>::Type>
-from_python<mx::ClangABI>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OnOffSwitch>::Type>
-from_python<mx::OnOffSwitch>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeAttr>::Type>
-from_python<mx::ObjCBridgeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedOnNonZeroAttr>::Type>
-from_python<mx::OSReturnsRetainedOnNonZeroAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwitchStmt>::Type>
-from_python<mx::SwitchStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CommentKind>::Type>
-from_python<mx::CommentKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DefaultStmt>::Type>
-from_python<mx::DefaultStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OnStackType>::Type>
-from_python<mx::OnStackType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPAdjustArgsOpKind>::Type>
-from_python<mx::OpenMPAdjustArgsOpKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Macro>::Type>
-from_python<mx::Macro>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AliasScopeDomainAttr>::Type>
-from_python<mx::ir::llvm::AliasScopeDomainAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AbsOp>::Type>
-from_python<mx::ir::llvm::AbsOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXStaticCastExpr>::Type>
-from_python<mx::CXXStaticCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ComparisonCategoryResult>::Type>
-from_python<mx::ComparisonCategoryResult>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXFunctionalCastExpr>::Type>
-from_python<mx::CXXFunctionalCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPAtClauseKind>::Type>
-from_python<mx::OpenMPAtClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RecoveryExpr>::Type>
-from_python<mx::RecoveryExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPAtomicDefaultMemOrderClauseKind>::Type>
-from_python<mx::OpenMPAtomicDefaultMemOrderClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PredefinedExpr>::Type>
-from_python<mx::PredefinedExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPBindClauseKind>::Type>
-from_python<mx::OpenMPBindClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AliasScopeAttr>::Type>
-from_python<mx::ir::llvm::AliasScopeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDefaultmapClauseKind>::Type>
-from_python<mx::OpenMPDefaultmapClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedMacroId>::Type>
-from_python<PackedMacroId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MemberExpr>::Type>
-from_python<mx::MemberExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtTryStmt>::Type>
-from_python<mx::ObjCAtTryStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MaterializeTemporaryExpr>::Type>
-from_python<mx::MaterializeTemporaryExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLImportStaticLocalAttr>::Type>
-from_python<mx::DLLImportStaticLocalAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtSynchronizedStmt>::Type>
-from_python<mx::ObjCAtSynchronizedStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLExportStaticLocalAttr>::Type>
-from_python<mx::DLLExportStaticLocalAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DivUOp>::Type>
-from_python<mx::ir::hl::DivUOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DivUAssignOp>::Type>
-from_python<mx::ir::hl::DivUAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenTreeNode>::Type>
-from_python<mx::TokenTreeNode>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ComparisonCategoryType>::Type>
-from_python<mx::ComparisonCategoryType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDefaultmapClauseModifier>::Type>
-from_python<mx::OpenMPDefaultmapClauseModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCTypeParamType>::Type>
-from_python<mx::ObjCTypeParamType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDependClauseKind>::Type>
-from_python<mx::OpenMPDependClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCInterfaceType>::Type>
-from_python<mx::ObjCInterfaceType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenTokenTreeNode>::Type>
-from_python<mx::TokenTokenTreeNode>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AccessGroupAttr>::Type>
-from_python<mx::ir::llvm::AccessGroupAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CompilingModuleKind>::Type>
-from_python<mx::CompilingModuleKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDeviceClauseModifier>::Type>
-from_python<mx::OpenMPDeviceClauseModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDistributeParallelForSimdDirective>::Type>
-from_python<mx::OMPDistributeParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::GetActiveLaneMaskOp>::Type>
-from_python<mx::ir::llvm::GetActiveLaneMaskOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDistributeDirective>::Type>
-from_python<mx::OMPDistributeDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ComplexRangeKind>::Type>
-from_python<mx::ComplexRangeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstantResultStorageKind>::Type>
-from_python<mx::ConstantResultStorageKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ChoiceTokenTreeNode>::Type>
-from_python<mx::ChoiceTokenTreeNode>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::TBAARootAttr>::Type>
-from_python<mx::ir::llvm::TBAARootAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstexprSpecKind>::Type>
-from_python<mx::ConstexprSpecKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDeviceType>::Type>
-from_python<mx::OpenMPDeviceType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPUnrollDirective>::Type>
-from_python<mx::OMPUnrollDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoreFoundationABI>::Type>
-from_python<mx::CoreFoundationABI>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlwaysDestroyAttr>::Type>
-from_python<mx::AlwaysDestroyAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPLoopDirective>::Type>
-from_python<mx::OMPLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroKind>::Type>
-from_python<mx::MacroKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AllocAlignAttr>::Type>
-from_python<mx::AllocAlignAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::MacroKind>>::Type>
-from_python<std::span<const mx::MacroKind>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstitutionTokenTreeNode>::Type>
-from_python<mx::SubstitutionTokenTreeNode>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DataPositionTy>::Type>
-from_python<mx::DataPositionTy>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConditionalMacroDirective>::Type>
-from_python<mx::ConditionalMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::TBAAMemberAttr>::Type>
-from_python<mx::ir::llvm::TBAAMemberAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AnnotationOp>::Type>
-from_python<mx::ir::llvm::AnnotationOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeductionCandidate>::Type>
-from_python<mx::DeductionCandidate>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EndIfMacroDirective>::Type>
-from_python<mx::EndIfMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SequenceTokenTreeNode>::Type>
-from_python<mx::SequenceTokenTreeNode>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::InvariantEndOp>::Type>
-from_python<mx::ir::llvm::InvariantEndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::InvariantStartOp>::Type>
-from_python<mx::ir::llvm::InvariantStartOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDistScheduleClauseKind>::Type>
-from_python<mx::OpenMPDistScheduleClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::TBAATagAttr>::Type>
-from_python<mx::ir::llvm::TBAATagAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDoacrossClauseModifier>::Type>
-from_python<mx::OpenMPDoacrossClauseModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedOnZeroAttr>::Type>
-from_python<mx::OSReturnsRetainedOnZeroAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedAttr>::Type>
-from_python<mx::OSReturnsRetainedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DefaultArgKind>::Type>
-from_python<mx::DefaultArgKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LoaderUninitializedAttr>::Type>
-from_python<mx::LoaderUninitializedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IBOutletAttr>::Type>
-from_python<mx::IBOutletAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AssumeOp>::Type>
-from_python<mx::ir::llvm::AssumeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCInterfaceDecl>::Type>
-from_python<mx::ObjCInterfaceDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPGrainsizeClauseModifier>::Type>
-from_python<mx::OpenMPGrainsizeClauseModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPLinearClauseKind>::Type>
-from_python<mx::OpenMPLinearClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMasterTaskLoopSimdDirective>::Type>
-from_python<mx::OMPParallelMasterTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPLastprivateModifier>::Type>
-from_python<mx::OpenMPLastprivateModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::BitReverseOp>::Type>
-from_python<mx::ir::llvm::BitReverseOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMaskedTaskLoopSimdDirective>::Type>
-from_python<mx::OMPParallelMaskedTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DefaultCallingConvention>::Type>
-from_python<mx::DefaultCallingConvention>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCContainerDecl>::Type>
-from_python<mx::ObjCContainerDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::TBAATypeDescriptorAttr>::Type>
-from_python<mx::ir::llvm::TBAATypeDescriptorAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::IsConstantOp>::Type>
-from_python<mx::ir::llvm::IsConstantOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DoOp>::Type>
-from_python<mx::ir::hl::DoOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXMethodDecl>::Type>
-from_python<mx::CXXMethodDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDestructorDecl>::Type>
-from_python<mx::CXXDestructorDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::IfOp>::Type>
-from_python<mx::ir::hl::IfOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ImagOp>::Type>
-from_python<mx::ir::hl::ImagOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UMinOp>::Type>
-from_python<mx::ir::llvm::UMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionDecl>::Type>
-from_python<mx::FunctionDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Reference>::Type>
-from_python<mx::Reference>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::LazyOp>::Type>
-from_python<mx::ir::core::LazyOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SourceLocExpr>::Type>
-from_python<mx::SourceLocExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AddressOfOp>::Type>
-from_python<mx::ir::hl::AddressOfOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::ImplicitReturnOp>::Type>
-from_python<mx::ir::core::ImplicitReturnOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReferenceKind>::Type>
-from_python<mx::ReferenceKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MaxNumOp>::Type>
-from_python<mx::ir::llvm::MaxNumOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ImplicitCastOp>::Type>
-from_python<mx::ir::hl::ImplicitCastOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitParamDecl>::Type>
-from_python<mx::ImplicitParamDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinReferenceKind>::Type>
-from_python<mx::BuiltinReferenceKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UMulWithOverflowOp>::Type>
-from_python<mx::ir::llvm::UMulWithOverflowOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedOperationId>::Type>
-from_python<PackedOperationId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AlignOfExprOp>::Type>
-from_python<mx::ir::hl::AlignOfExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::string_view>::Type>
-from_python<std::string_view>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MaximumOp>::Type>
-from_python<mx::ir::llvm::MaximumOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IndirectFieldDecl>::Type>
-from_python<mx::IndirectFieldDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::IndirectCallOp>::Type>
-from_python<mx::ir::hl::IndirectCallOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UShlSatOp>::Type>
-from_python<mx::ir::llvm::UShlSatOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::string>::Type>
-from_python<std::string>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::ScopeOp>::Type>
-from_python<mx::ir::core::ScopeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AsmOp>::Type>
-from_python<mx::ir::hl::AsmOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AlignOfTypeOp>::Type>
-from_python<mx::ir::hl::AlignOfTypeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::ModuleOp>::Type>
-from_python<mx::ir::core::ModuleOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MemcpyInlineOp>::Type>
-from_python<mx::ir::llvm::MemcpyInlineOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::USubSatOp>::Type>
-from_python<mx::ir::llvm::USubSatOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConstructExpr>::Type>
-from_python<mx::CXXConstructExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::IndirectGotoStmtOp>::Type>
-from_python<mx::ir::hl::IndirectGotoStmtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::StmtKind>>::Type>
-from_python<std::span<const mx::StmtKind>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IntegerLiteral>::Type>
-from_python<mx::IntegerLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingPackDecl>::Type>
-from_python<mx::UsingPackDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Type>::Type>
-from_python<mx::Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MemcpyOp>::Type>
-from_python<mx::ir::llvm::MemcpyOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::InitListExprOp>::Type>
-from_python<mx::ir::hl::InitListExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::USubWithOverflowOp>::Type>
-from_python<mx::ir::llvm::USubWithOverflowOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedTypeId>::Type>
-from_python<PackedTypeId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NamespaceAliasDecl>::Type>
-from_python<mx::NamespaceAliasDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExternCContextDecl>::Type>
-from_python<mx::ExternCContextDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MemmoveOp>::Type>
-from_python<mx::ir::llvm::MemmoveOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionTemplateDecl>::Type>
-from_python<mx::FunctionTemplateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LNotOp>::Type>
-from_python<mx::ir::hl::LNotOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmOutAttr>::Type>
-from_python<mx::ArmOutAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AssignOp>::Type>
-from_python<mx::ir::hl::AssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::InitializedConstantOp>::Type>
-from_python<mx::ir::hl::InitializedConstantOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPAddOp>::Type>
-from_python<mx::ir::llvm::VPAddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::TypeKind>>::Type>
-from_python<std::span<const mx::TypeKind>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPAShrOp>::Type>
-from_python<mx::ir::llvm::VPAShrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MemsetOp>::Type>
-from_python<mx::ir::llvm::MemsetOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NonTypeTemplateParmDecl>::Type>
-from_python<mx::NonTypeTemplateParmDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftVersionedRemovalAttr>::Type>
-from_python<mx::SwiftVersionedRemovalAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoCommonAttr>::Type>
-from_python<mx::NoCommonAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangBSSSectionAttr>::Type>
-from_python<mx::PragmaClangBSSSectionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PcsAttr>::Type>
-from_python<mx::PcsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AssumptionAttr>::Type>
-from_python<mx::AssumptionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::meta::Attribute>::Type>
-from_python<mx::ir::meta::Attribute>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MinNumOp>::Type>
-from_python<mx::ir::llvm::MinNumOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AttributedStmtOp>::Type>
-from_python<mx::ir::hl::AttributedStmtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Attribute>::Type>
-from_python<mx::ir::Attribute>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPAndOp>::Type>
-from_python<mx::ir::llvm::VPAndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRuntimeVisibleAttr>::Type>
-from_python<mx::ObjCRuntimeVisibleAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::unsup::Type>::Type>
-from_python<mx::ir::unsup::Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnforceTCBLeafAttr>::Type>
-from_python<mx::EnforceTCBLeafAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RISCVInterruptAttr>::Type>
-from_python<mx::RISCVInterruptAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::meta::IdentifierAttr>::Type>
-from_python<mx::ir::meta::IdentifierAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeOfType>::Type>
-from_python<mx::TypeOfType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinAShrAssignOp>::Type>
-from_python<mx::ir::hl::BinAShrAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SEHLeaveStmt>::Type>
-from_python<mx::SEHLeaveStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LabelDeclOp>::Type>
-from_python<mx::ir::hl::LabelDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MinimumOp>::Type>
-from_python<mx::ir::llvm::MinimumOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSubclassingRestrictedAttr>::Type>
-from_python<mx::ObjCSubclassingRestrictedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFICanonicalJumpTableAttr>::Type>
-from_python<mx::CFICanonicalJumpTableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSABIAttr>::Type>
-from_python<mx::MSABIAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParmVarDecl>::Type>
-from_python<mx::ParmVarDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CastExpr>::Type>
-from_python<mx::CastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Type>::Type>
-from_python<mx::ir::Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateArgument>::Type>
-from_python<mx::TemplateArgument>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RecordDecl>::Type>
-from_python<mx::RecordDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmMveStrictPolymorphismAttr>::Type>
-from_python<mx::ArmMveStrictPolymorphismAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::unsup::UnsupportedType>::Type>
-from_python<mx::ir::unsup::UnsupportedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::MinusOp>::Type>
-from_python<mx::ir::hl::MinusOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TagDecl>::Type>
-from_python<mx::TagDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LabelStmtOp>::Type>
-from_python<mx::ir::hl::LabelStmtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::RoundToNearbyIntOp>::Type>
-from_python<mx::ir::llvm::RoundToNearbyIntOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinAShrOp>::Type>
-from_python<mx::ir::hl::BinAShrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSPropertyDecl>::Type>
-from_python<mx::MSPropertyDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeDecl>::Type>
-from_python<mx::TypeDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoAliasAttr>::Type>
-from_python<mx::NoAliasAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedTemplateArgumentId>::Type>
-from_python<PackedTemplateArgumentId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::unsup::Operation>::Type>
-from_python<mx::ir::unsup::Operation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftVersionedAdditionAttr>::Type>
-from_python<mx::SwiftVersionedAdditionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PointerAttr>::Type>
-from_python<mx::PointerAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AssumeAlignedAttr>::Type>
-from_python<mx::AssumeAlignedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::unsup::UnsupportedDeclOp>::Type>
-from_python<mx::ir::unsup::UnsupportedDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::PowIOp>::Type>
-from_python<mx::ir::llvm::PowIOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::NoAliasScopeDeclOp>::Type>
-from_python<mx::ir::llvm::NoAliasScopeDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinAndAssignOp>::Type>
-from_python<mx::ir::hl::BinAndAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRuntimeNameAttr>::Type>
-from_python<mx::ObjCRuntimeNameAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFAddOp>::Type>
-from_python<mx::ir::llvm::VPFAddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeOfExprType>::Type>
-from_python<mx::TypeOfExprType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnforceTCBAttr>::Type>
-from_python<mx::EnforceTCBAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PureAttr>::Type>
-from_python<mx::PureAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDependentScopeMemberExpr>::Type>
-from_python<mx::CXXDependentScopeMemberExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FPowOp>::Type>
-from_python<mx::ir::llvm::FPowOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::MulFOp>::Type>
-from_python<mx::ir::hl::MulFOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRootClassAttr>::Type>
-from_python<mx::ObjCRootClassAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::DeclKind>>::Type>
-from_python<std::span<const mx::DeclKind>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::MulFAssignOp>::Type>
-from_python<mx::ir::hl::MulFAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFGuardAttr>::Type>
-from_python<mx::CFGuardAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MIGServerRoutineAttr>::Type>
-from_python<mx::MIGServerRoutineAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::unsup::UnsupportedStmtOp>::Type>
-from_python<mx::ir::unsup::UnsupportedStmtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::TemplateArgument>>::Type>
-from_python<std::optional<mx::TemplateArgument>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMasterDirective>::Type>
-from_python<mx::OMPParallelMasterDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinAndOp>::Type>
-from_python<mx::ir::hl::BinAndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelDirective>::Type>
-from_python<mx::OMPParallelDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmInOutAttr>::Type>
-from_python<mx::ArmInOutAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFDivOp>::Type>
-from_python<mx::ir::llvm::VPFDivOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NakedAttr>::Type>
-from_python<mx::NakedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsAutoreleasedAttr>::Type>
-from_python<mx::NSReturnsAutoreleasedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftObjCMembersAttr>::Type>
-from_python<mx::SwiftObjCMembersAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FullExpr>::Type>
-from_python<mx::FullExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLUnrollHintAttr>::Type>
-from_python<mx::OpenCLUnrollHintAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstantExpr>::Type>
-from_python<mx::ConstantExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinCommaOp>::Type>
-from_python<mx::ir::hl::BinCommaOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PascalAttr>::Type>
-from_python<mx::PascalAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateParameterList>::Type>
-from_python<mx::TemplateParameterList>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AssertSharedLockAttr>::Type>
-from_python<mx::AssertSharedLockAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AssertCapabilityAttr>::Type>
-from_python<mx::AssertCapabilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SEHTryStmt>::Type>
-from_python<mx::SEHTryStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSelectorExpr>::Type>
-from_python<mx::ObjCSelectorExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnStmt>::Type>
-from_python<mx::ReturnStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VAArgExpr>::Type>
-from_python<mx::VAArgExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::PrefetchOp>::Type>
-from_python<mx::ir::llvm::PrefetchOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryExprOrTypeTraitExpr>::Type>
-from_python<mx::UnaryExprOrTypeTraitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFMulAddOp>::Type>
-from_python<mx::ir::llvm::VPFMulAddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSubscriptRefExpr>::Type>
-from_python<mx::ObjCSubscriptRefExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNonRuntimeProtocolAttr>::Type>
-from_python<mx::ObjCNonRuntimeProtocolAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PtGuardedVarAttr>::Type>
-from_python<mx::PtGuardedVarAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDirectMembersAttr>::Type>
-from_python<mx::ObjCDirectMembersAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PreserveMostAttr>::Type>
-from_python<mx::PreserveMostAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnableIfAttr>::Type>
-from_python<mx::EnableIfAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::MulIAssignOp>::Type>
-from_python<mx::ir::hl::MulIAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::MulIOp>::Type>
-from_python<mx::ir::hl::MulIOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DisableTailCallsAttr>::Type>
-from_python<mx::DisableTailCallsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedTemplateParameterListId>::Type>
-from_python<PackedTemplateParameterListId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CharacterLiteral>::Type>
-from_python<mx::CharacterLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitCastExpr>::Type>
-from_python<mx::ImplicitCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Value>::Type>
-from_python<mx::ir::Value>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinLAndOp>::Type>
-from_python<mx::ir::hl::BinLAndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCReturnsInnerPointerAttr>::Type>
-from_python<mx::ObjCReturnsInnerPointerAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRequiresPropertyDefsAttr>::Type>
-from_python<mx::ObjCRequiresPropertyDefsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::M68kRTDAttr>::Type>
-from_python<mx::M68kRTDAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LocksExcludedAttr>::Type>
-from_python<mx::LocksExcludedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstructorUsingShadowDecl>::Type>
-from_python<mx::ConstructorUsingShadowDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFAuditedTransferAttr>::Type>
-from_python<mx::CFAuditedTransferAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingDirectiveDecl>::Type>
-from_python<mx::UsingDirectiveDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::C11NoReturnAttr>::Type>
-from_python<mx::C11NoReturnAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::ScopeRecurseOp>::Type>
-from_python<mx::ir::ll::ScopeRecurseOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ImaginaryLiteral>::Type>
-from_python<mx::ImaginaryLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::PtrAnnotationOp>::Type>
-from_python<mx::ir::llvm::PtrAnnotationOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmInAttr>::Type>
-from_python<mx::ArmInAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AddressSpaceAttr>::Type>
-from_python<mx::AddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::NotOp>::Type>
-from_python<mx::ir::hl::NotOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFMulOp>::Type>
-from_python<mx::ir::llvm::VPFMulOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::RoundToIntOp>::Type>
-from_python<mx::ir::llvm::RoundToIntOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NVPTXKernelAttr>::Type>
-from_python<mx::NVPTXKernelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsNotRetainedAttr>::Type>
-from_python<mx::NSReturnsNotRetainedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinLOrOp>::Type>
-from_python<mx::ir::hl::BinLOrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::TemplateParameterList>>::Type>
-from_python<std::optional<mx::TemplateParameterList>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StmtAttr>::Type>
-from_python<mx::StmtAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MustTailAttr>::Type>
-from_python<mx::MustTailAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ImportDecl>::Type>
-from_python<mx::ImportDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FriendTemplateDecl>::Type>
-from_python<mx::FriendTemplateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PatchableFunctionEntryAttr>::Type>
-from_python<mx::PatchableFunctionEntryAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParamTypestateAttr>::Type>
-from_python<mx::ParamTypestateAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDeleteExpr>::Type>
-from_python<mx::CXXDeleteExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExternalSourceSymbolAttr>::Type>
-from_python<mx::ExternalSourceSymbolAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AssertExclusiveLockAttr>::Type>
-from_python<mx::AssertExclusiveLockAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AsmLabelAttr>::Type>
-from_python<mx::AsmLabelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXBaseSpecifier>::Type>
-from_python<mx::CXXBaseSpecifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Designator>::Type>
-from_python<mx::Designator>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InheritableAttr>::Type>
-from_python<mx::InheritableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMaskedDirective>::Type>
-from_python<mx::OMPParallelMaskedDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPOrderedDirective>::Type>
-from_python<mx::OMPOrderedDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFNegOp>::Type>
-from_python<mx::ir::llvm::VPFNegOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNonLazyClassAttr>::Type>
-from_python<mx::ObjCNonLazyClassAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXCtorInitializer>::Type>
-from_python<mx::CXXCtorInitializer>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::RoundToNearestEvenOp>::Type>
-from_python<mx::ir::llvm::RoundToNearestEvenOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PtGuardedByAttr>::Type>
-from_python<mx::PtGuardedByAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDirectAttr>::Type>
-from_python<mx::ObjCDirectAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PreserveAllAttr>::Type>
-from_python<mx::PreserveAllAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinLShrAssignOp>::Type>
-from_python<mx::ir::hl::BinLShrAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EmptyBasesAttr>::Type>
-from_python<mx::EmptyBasesAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DisableSanitizerInstrumentationAttr>::Type>
-from_python<mx::DisableSanitizerInstrumentationAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRequiresSuperAttr>::Type>
-from_python<mx::ObjCRequiresSuperAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenRange>::Type>
-from_python<mx::TokenRange>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPreciseLifetimeAttr>::Type>
-from_python<mx::ObjCPreciseLifetimeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::M68kInterruptAttr>::Type>
-from_python<mx::M68kInterruptAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LockReturnedAttr>::Type>
-from_python<mx::LockReturnedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::NullStmtOp>::Type>
-from_python<mx::ir::hl::NullStmtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CDeclAttr>::Type>
-from_python<mx::CDeclAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenTree>::Type>
-from_python<mx::TokenTree>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinAttr>::Type>
-from_python<mx::BuiltinAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StmtExpr>::Type>
-from_python<mx::StmtExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SizeOfPackExpr>::Type>
-from_python<mx::SizeOfPackExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprWithCleanups>::Type>
-from_python<mx::ExprWithCleanups>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FloatingLiteral>::Type>
-from_python<mx::FloatingLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SAddSatOp>::Type>
-from_python<mx::ir::llvm::SAddSatOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::RoundToNearestOp>::Type>
-from_python<mx::ir::llvm::RoundToNearestOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnnotateTypeAttr>::Type>
-from_python<mx::AnnotateTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFPToSIOp>::Type>
-from_python<mx::ir::llvm::VPFPToSIOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyFuncrefAttr>::Type>
-from_python<mx::WebAssemblyFuncrefAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFPExtOp>::Type>
-from_python<mx::ir::llvm::VPFPExtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinOrAssignOp>::Type>
-from_python<mx::ir::hl::BinOrAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SEHExceptStmt>::Type>
-from_python<mx::SEHExceptStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinLShrOp>::Type>
-from_python<mx::ir::hl::BinLShrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::OffsetOfExprOp>::Type>
-from_python<mx::ir::hl::OffsetOfExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedCXXBaseSpecifierId>::Type>
-from_python<PackedCXXBaseSpecifierId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::OpaqueValueExprOp>::Type>
-from_python<mx::ir::hl::OpaqueValueExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsRetainedAttr>::Type>
-from_python<mx::NSReturnsRetainedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryOperator>::Type>
-from_python<mx::UnaryOperator>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypoExpr>::Type>
-from_python<mx::TypoExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::vector<std::variant<mx::TokenRange, mx::TokenTreeNode>>>::Type>
-from_python<std::vector<std::variant<mx::TokenRange, mx::TokenTreeNode>>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ParenType>::Type>
-from_python<mx::ir::hl::ParenType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSGuidDecl>::Type>
-from_python<mx::MSGuidDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::CXXBaseSpecifier>>::Type>
-from_python<std::optional<mx::CXXBaseSpecifier>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopVectorizeAttr>::Type>
-from_python<mx::ir::llvm::LoopVectorizeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::SizeOfExprOp>::Type>
-from_python<mx::ir::hl::SizeOfExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumDecl>::Type>
-from_python<mx::EnumDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXRecordDecl>::Type>
-from_python<mx::CXXRecordDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::SizeOfTypeOp>::Type>
-from_python<mx::ir::hl::SizeOfTypeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedDesignatorId>::Type>
-from_python<PackedDesignatorId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::StaticAssertDeclOp>::Type>
-from_python<mx::ir::hl::StaticAssertDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<uint64_t>::Type>
-from_python<uint64_t>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<uint32_t>::Type>
-from_python<uint32_t>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::StmtExprOp>::Type>
-from_python<mx::ir::hl::StmtExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXTemporaryObjectExpr>::Type>
-from_python<mx::CXXTemporaryObjectExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<bool>::Type>
-from_python<bool>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Designator>>::Type>
-from_python<std::optional<mx::Designator>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoStackProtectorAttr>::Type>
-from_python<mx::NoStackProtectorAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DecompositionDecl>::Type>
-from_python<mx::DecompositionDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::StructDeclOp>::Type>
-from_python<mx::ir::hl::StructDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VarTemplatePartialSpecializationDecl>::Type>
-from_python<mx::VarTemplatePartialSpecializationDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateTypeParmType>::Type>
-from_python<mx::TemplateTypeParmType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TagType>::Type>
-from_python<mx::TagType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GuardedByAttr>::Type>
-from_python<mx::GuardedByAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ZeroOp>::Type>
-from_python<mx::ir::llvm::ZeroOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroQualifiedType>::Type>
-from_python<mx::MacroQualifiedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumConstantDecl>::Type>
-from_python<mx::EnumConstantDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetVersionAttr>::Type>
-from_python<mx::TargetVersionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MinVectorWidthAttr>::Type>
-from_python<mx::MinVectorWidthAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::SubFAssignOp>::Type>
-from_python<mx::ir::hl::SubFAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::SubFOp>::Type>
-from_python<mx::ir::hl::SubFOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLConstantAddressSpaceAttr>::Type>
-from_python<mx::OpenCLConstantAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedCXXCtorInitializerId>::Type>
-from_python<PackedCXXCtorInitializerId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateTypeParmDecl>::Type>
-from_python<mx::TemplateTypeParmDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSplitStackAttr>::Type>
-from_python<mx::NoSplitStackAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDepobjDirective>::Type>
-from_python<mx::OMPDepobjDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCancellationPointDirective>::Type>
-from_python<mx::OMPCancellationPointDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InjectedClassNameType>::Type>
-from_python<mx::InjectedClassNameType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::CXXCtorInitializer>>::Type>
-from_python<std::optional<mx::CXXCtorInitializer>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GNUInlineAttr>::Type>
-from_python<mx::GNUInlineAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::SubIOp>::Type>
-from_python<mx::ir::hl::SubIOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::SubIAssignOp>::Type>
-from_python<mx::ir::hl::SubIAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BlockExpr>::Type>
-from_python<mx::BlockExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MinSizeAttr>::Type>
-from_python<mx::MinSizeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskwaitDirective>::Type>
-from_python<mx::OMPTaskwaitDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskDirective>::Type>
-from_python<mx::OMPTaskDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetClonesAttr>::Type>
-from_python<mx::TargetClonesAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCKindOfAttr>::Type>
-from_python<mx::ObjCKindOfAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArraySubscriptExpr>::Type>
-from_python<mx::ArraySubscriptExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FieldDecl>::Type>
-from_python<mx::FieldDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BindingDecl>::Type>
-from_python<mx::BindingDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetDirective>::Type>
-from_python<mx::OMPTargetDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPSingleDirective>::Type>
-from_python<mx::OMPSingleDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::OperationKind>::Type>
-from_python<mx::ir::OperationKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnusedAttr>::Type>
-from_python<mx::UnusedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FShrOp>::Type>
-from_python<mx::ir::llvm::FShrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSpeculativeLoadHardeningAttr>::Type>
-from_python<mx::NoSpeculativeLoadHardeningAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionType>::Type>
-from_python<mx::FunctionType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionNoProtoType>::Type>
-from_python<mx::FunctionNoProtoType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::SubscriptOp>::Type>
-from_python<mx::ir::hl::SubscriptOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionReturnThunksAttr>::Type>
-from_python<mx::FunctionReturnThunksAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FlagEnumAttr>::Type>
-from_python<mx::FlagEnumAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDistributeSimdDirective>::Type>
-from_python<mx::OMPTargetTeamsDistributeSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDistributeParallelForDirective>::Type>
-from_python<mx::OMPTargetTeamsDistributeParallelForDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBoxedExpr>::Type>
-from_python<mx::ObjCBoxedExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypedefDecl>::Type>
-from_python<mx::TypedefDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAvailabilityCheckExpr>::Type>
-from_python<mx::ObjCAvailabilityCheckExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinTemplateDecl>::Type>
-from_python<mx::BuiltinTemplateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MicroMipsAttr>::Type>
-from_python<mx::MicroMipsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MayAliasAttr>::Type>
-from_python<mx::MayAliasAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateParamObjectDecl>::Type>
-from_python<mx::TemplateParamObjectDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AttrKind>::Type>
-from_python<mx::AttrKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetAttr>::Type>
-from_python<mx::TargetAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SysVABIAttr>::Type>
-from_python<mx::SysVABIAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ThisOp>::Type>
-from_python<mx::ir::hl::ThisOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AArch64VectorPcsAttrSpelling>::Type>
-from_python<mx::AArch64VectorPcsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCInertUnsafeUnretainedAttr>::Type>
-from_python<mx::ObjCInertUnsafeUnretainedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::SwitchOp>::Type>
-from_python<mx::ir::hl::SwitchOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDerefAttr>::Type>
-from_python<mx::NoDerefAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCriticalDirective>::Type>
-from_python<mx::OMPCriticalDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCancelDirective>::Type>
-from_python<mx::OMPCancelDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnsafeBufferUsageAttr>::Type>
-from_python<mx::UnsafeBufferUsageAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Result>::Type>
-from_python<mx::ir::Result>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnavailableAttr>::Type>
-from_python<mx::UnavailableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSanitizeAttr>::Type>
-from_python<mx::NoSanitizeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoRandomizeLayoutAttr>::Type>
-from_python<mx::NoRandomizeLayoutAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXBindTemporaryExpr>::Type>
-from_python<mx::CXXBindTemporaryExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BinaryOperator>::Type>
-from_python<mx::BinaryOperator>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskgroupDirective>::Type>
-from_python<mx::OMPTaskgroupDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetUpdateDirective>::Type>
-from_python<mx::OMPTargetUpdateDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateSpecializationType>::Type>
-from_python<mx::TemplateSpecializationType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionProtoType>::Type>
-from_python<mx::FunctionProtoType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RecordType>::Type>
-from_python<mx::RecordType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentVectorType>::Type>
-from_python<mx::DependentVectorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ValueKind>::Type>
-from_python<mx::ir::ValueKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FormatAttr>::Type>
-from_python<mx::FormatAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FlattenAttr>::Type>
-from_python<mx::FlattenAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TranslationUnitOp>::Type>
-from_python<mx::ir::hl::TranslationUnitOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetDataDirective>::Type>
-from_python<mx::OMPTargetDataDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayTypeTraitExpr>::Type>
-from_python<mx::ArrayTypeTraitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPSectionsDirective>::Type>
-from_python<mx::OMPSectionsDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayInitLoopExpr>::Type>
-from_python<mx::ArrayInitLoopExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AArch64SVEPcsAttrSpelling>::Type>
-from_python<mx::AArch64SVEPcsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlwaysInlineAttrSpelling>::Type>
-from_python<mx::AlwaysInlineAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::TypeKind>::Type>
-from_python<mx::ir::TypeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MaybeUndefAttr>::Type>
-from_python<mx::MaybeUndefAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::YieldOp>::Type>
-from_python<mx::ir::abi::YieldOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUFlatWorkGroupSizeAttrSpelling>::Type>
-from_python<mx::AMDGPUFlatWorkGroupSizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MaxFieldAlignmentAttr>::Type>
-from_python<mx::MaxFieldAlignmentAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUKernelCallAttrSpelling>::Type>
-from_python<mx::AMDGPUKernelCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUNumSGPRAttrSpelling>::Type>
-from_python<mx::AMDGPUNumSGPRAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUNumVGPRAttrSpelling>::Type>
-from_python<mx::AMDGPUNumVGPRAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUWavesPerEUAttrSpelling>::Type>
-from_python<mx::AMDGPUWavesPerEUAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopDistributeAttr>::Type>
-from_python<mx::ir::llvm::LoopDistributeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCGCAttr>::Type>
-from_python<mx::ObjCGCAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TypeAliasOp>::Type>
-from_python<mx::ir::hl::TypeAliasOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ARMInterruptAttrInterruptType>::Type>
-from_python<mx::ARMInterruptAttrInterruptType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLParamModifierAttr>::Type>
-from_python<mx::HLSLParamModifierAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TLSModelAttr>::Type>
-from_python<mx::TLSModelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ARMInterruptAttrSpelling>::Type>
-from_python<mx::ARMInterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftPrivateAttr>::Type>
-from_python<mx::SwiftPrivateAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AVRInterruptAttrSpelling>::Type>
-from_python<mx::AVRInterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Operand>::Type>
-from_python<mx::ir::Operand>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AVRSignalAttrSpelling>::Type>
-from_python<mx::AVRSignalAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AbiTagAttrSpelling>::Type>
-from_python<mx::AbiTagAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquireCapabilityAttrSpelling>::Type>
-from_python<mx::AcquireCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquireHandleAttrSpelling>::Type>
-from_python<mx::AcquireHandleAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDistributeParallelForSimdDirective>::Type>
-from_python<mx::OMPTargetTeamsDistributeParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TypeDefOp>::Type>
-from_python<mx::ir::hl::TypeDefOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDistributeDirective>::Type>
-from_python<mx::OMPTargetTeamsDistributeDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TypeDeclOp>::Type>
-from_python<mx::ir::hl::TypeDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AddressSpaceAttrSpelling>::Type>
-from_python<mx::AddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UninitializedAttr>::Type>
-from_python<mx::UninitializedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AliasAttrSpelling>::Type>
-from_python<mx::AliasAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeVisibilityAttr>::Type>
-from_python<mx::TypeVisibilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoReturnAttr>::Type>
-from_python<mx::NoReturnAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignedAttrSpelling>::Type>
-from_python<mx::AlignedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoProfileFunctionAttr>::Type>
-from_python<mx::NoProfileFunctionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AllocAlignAttrSpelling>::Type>
-from_python<mx::AllocAlignAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBoolLiteralExpr>::Type>
-from_python<mx::ObjCBoolLiteralExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeAliasDecl>::Type>
-from_python<mx::TypeAliasDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateTemplateParmDecl>::Type>
-from_python<mx::TemplateTemplateParmDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumType>::Type>
-from_python<mx::EnumType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCArrayLiteral>::Type>
-from_python<mx::ObjCArrayLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AllocSizeAttrSpelling>::Type>
-from_python<mx::AllocSizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FormatArgAttr>::Type>
-from_python<mx::FormatArgAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedUsingValueDecl>::Type>
-from_python<mx::UnresolvedUsingValueDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlwaysDestroyAttrSpelling>::Type>
-from_python<mx::AlwaysDestroyAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::FormatAttr>::Type>
-from_python<mx::ir::hl::FormatAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::BrOp>::Type>
-from_python<mx::ir::llvm::BrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::SectionAttr>::Type>
-from_python<mx::ir::hl::SectionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ForStmt>::Type>
-from_python<mx::ForStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::SubViewOp>::Type>
-from_python<mx::ir::memref::SubViewOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AliasAttr>::Type>
-from_python<mx::ir::hl::AliasAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ByteSwapOp>::Type>
-from_python<mx::ir::llvm::ByteSwapOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwitchCase>::Type>
-from_python<mx::SwitchCase>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::IsFPClassOp>::Type>
-from_python<mx::ir::llvm::IsFPClassOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LShrOp>::Type>
-from_python<mx::ir::llvm::LShrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceSMaxOp>::Type>
-from_python<mx::ir::llvm::VectorReduceSMaxOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ErrorAttr>::Type>
-from_python<mx::ir::hl::ErrorAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CallOp>::Type>
-from_python<mx::ir::llvm::CallOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CallIntrinsicOp>::Type>
-from_python<mx::ir::llvm::CallIntrinsicOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::Operation>::Type>
-from_python<mx::ir::abi::Operation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConceptDecl>::Type>
-from_python<mx::ConceptDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CopySignOp>::Type>
-from_python<mx::ir::llvm::CopySignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CountedByAttr>::Type>
-from_python<mx::ir::hl::CountedByAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LifetimeEndOp>::Type>
-from_python<mx::ir::llvm::LifetimeEndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AnnotationAttr>::Type>
-from_python<mx::ir::hl::AnnotationAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LandingpadOp>::Type>
-from_python<mx::ir::llvm::LandingpadOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceSMinOp>::Type>
-from_python<mx::ir::llvm::VectorReduceSMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::CallArgsOp>::Type>
-from_python<mx::ir::abi::CallArgsOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CleanupAttr>::Type>
-from_python<mx::ir::hl::CleanupAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroAlignOp>::Type>
-from_python<mx::ir::llvm::CoroAlignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AlignedAttr>::Type>
-from_python<mx::ir::hl::AlignedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LifetimeStartOp>::Type>
-from_python<mx::ir::llvm::LifetimeStartOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoadOp>::Type>
-from_python<mx::ir::llvm::LoadOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LinkerOptionsOp>::Type>
-from_python<mx::ir::llvm::LinkerOptionsOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceUMaxOp>::Type>
-from_python<mx::ir::llvm::VectorReduceUMaxOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::CallOp>::Type>
-from_python<mx::ir::abi::CallOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::CallExecutionOp>::Type>
-from_python<mx::ir::abi::CallExecutionOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AlwaysInlineAttr>::Type>
-from_python<mx::ir::hl::AlwaysInlineAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroBeginOp>::Type>
-from_python<mx::ir::llvm::CoroBeginOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ComdatOp>::Type>
-from_python<mx::ir::llvm::ComdatOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::RoundAndCastToLongLongOp>::Type>
-from_python<mx::ir::llvm::RoundAndCastToLongLongOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MulOp>::Type>
-from_python<mx::ir::llvm::MulOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::NoInlineAttr>::Type>
-from_python<mx::ir::hl::NoInlineAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceUMinOp>::Type>
-from_python<mx::ir::llvm::VectorReduceUMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ConstAttr>::Type>
-from_python<mx::ir::hl::ConstAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroEndOp>::Type>
-from_python<mx::ir::llvm::CoroEndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ComdatSelectorOp>::Type>
-from_python<mx::ir::llvm::ComdatSelectorOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::Log10Op>::Type>
-from_python<mx::ir::llvm::Log10Op>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::RoundAndCastToNearestLongLongOp>::Type>
-from_python<mx::ir::llvm::RoundAndCastToNearestLongLongOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoyieldExpr>::Type>
-from_python<mx::CoyieldExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DoStmt>::Type>
-from_python<mx::DoStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LoaderUninitializedAttr>::Type>
-from_python<mx::ir::hl::LoaderUninitializedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLKernelAttr>::Type>
-from_python<mx::SYCLKernelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUNumSGPRAttr>::Type>
-from_python<mx::AMDGPUNumSGPRAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceXorOp>::Type>
-from_python<mx::ir::llvm::VectorReduceXorOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GotoStmt>::Type>
-from_python<mx::GotoStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CondBrOp>::Type>
-from_python<mx::ir::llvm::CondBrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroFreeOp>::Type>
-from_python<mx::ir::llvm::CoroFreeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclarativeDirectiveDecl>::Type>
-from_python<mx::OMPDeclarativeDirectiveDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::CallRetsOp>::Type>
-from_python<mx::ir::abi::CallRetsOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::NoInstrumentFunctionAttr>::Type>
-from_python<mx::ir::hl::NoInstrumentFunctionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::Log2Op>::Type>
-from_python<mx::ir::llvm::Log2Op>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ElaboratedType>::Type>
-from_python<mx::ElaboratedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DesignatedInitUpdateExpr>::Type>
-from_python<mx::DesignatedInitUpdateExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentScopeDeclRefExpr>::Type>
-from_python<mx::DependentScopeDeclRefExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LongType>::Type>
-from_python<mx::ir::hl::LongType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::OrOp>::Type>
-from_python<mx::ir::llvm::OrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PackedAttr>::Type>
-from_python<mx::ir::hl::PackedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VScaleOp>::Type>
-from_python<mx::ir::llvm::VScaleOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::NoneTokenOp>::Type>
-from_python<mx::ir::llvm::NoneTokenOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ConstantOp>::Type>
-from_python<mx::ir::llvm::ConstantOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDALaunchBoundsAttr>::Type>
-from_python<mx::CUDALaunchBoundsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroIdOp>::Type>
-from_python<mx::ir::llvm::CoroIdOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsNotRetainedAttr>::Type>
-from_python<mx::OSReturnsNotRetainedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::DirectOp>::Type>
-from_python<mx::ir::abi::DirectOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LongLongType>::Type>
-from_python<mx::ir::hl::LongLongType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LogOp>::Type>
-from_python<mx::ir::llvm::LogOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PureAttr>::Type>
-from_python<mx::ir::hl::PureAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakRefAttr>::Type>
-from_python<mx::WeakRefAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::Operation>::Type>
-from_python<mx::ir::memref::Operation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PassObjectSizeAttr>::Type>
-from_python<mx::PassObjectSizeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ExtractElementOp>::Type>
-from_python<mx::ir::llvm::ExtractElementOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::WarnUnusedResultAttr>::Type>
-from_python<mx::ir::hl::WarnUnusedResultAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroPromiseOp>::Type>
-from_python<mx::ir::llvm::CoroPromiseOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::FuncOp>::Type>
-from_python<mx::ir::abi::FuncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::AssumeAlignmentOp>::Type>
-from_python<mx::ir::memref::AssumeAlignmentOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::EpilogueOp>::Type>
-from_python<mx::ir::abi::EpilogueOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnsTwiceAttr>::Type>
-from_python<mx::ReturnsTwiceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RestrictAttr>::Type>
-from_python<mx::ir::hl::RestrictAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUKernelCallAttr>::Type>
-from_python<mx::AMDGPUKernelCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaCommentDecl>::Type>
-from_python<mx::PragmaCommentDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroResumeOp>::Type>
-from_python<mx::ir::llvm::CoroResumeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FAddOp>::Type>
-from_python<mx::ir::llvm::FAddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentTemplateSpecializationType>::Type>
-from_python<mx::DependentTemplateSpecializationType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ExtractValueOp>::Type>
-from_python<mx::ir::llvm::ExtractValueOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIvarRefExpr>::Type>
-from_python<mx::ObjCIvarRefExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::PoisonOp>::Type>
-from_python<mx::ir::llvm::PoisonOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::AtomicRMWOp>::Type>
-from_python<mx::ir::memref::AtomicRMWOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::NoThrowAttr>::Type>
-from_python<mx::ir::hl::NoThrowAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroSaveOp>::Type>
-from_python<mx::ir::llvm::CoroSaveOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::RoundAndCastToLongOp>::Type>
-from_python<mx::ir::llvm::RoundAndCastToLongOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::NonNullAttr>::Type>
-from_python<mx::ir::hl::NonNullAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FCmpOp>::Type>
-from_python<mx::ir::llvm::FCmpOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::PtrToIntOp>::Type>
-from_python<mx::ir::llvm::PtrToIntOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSConsumesThisAttr>::Type>
-from_python<mx::OSConsumesThisAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpaqueValueExpr>::Type>
-from_python<mx::OpaqueValueExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAInvalidTargetAttr>::Type>
-from_python<mx::CUDAInvalidTargetAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::CopyOp>::Type>
-from_python<mx::ir::memref::CopyOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXRewrittenBinaryOperator>::Type>
-from_python<mx::CXXRewrittenBinaryOperator>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LeafAttr>::Type>
-from_python<mx::ir::hl::LeafAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::AtomicYieldOp>::Type>
-from_python<mx::ir::memref::AtomicYieldOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXParenListInitExpr>::Type>
-from_python<mx::CXXParenListInitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LabelDecl>::Type>
-from_python<mx::LabelDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroSizeOp>::Type>
-from_python<mx::ir::llvm::CoroSizeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroutineBodyStmt>::Type>
-from_python<mx::CoroutineBodyStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ContinueStmt>::Type>
-from_python<mx::ContinueStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakImportAttr>::Type>
-from_python<mx::WeakImportAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParameterABIAttr>::Type>
-from_python<mx::ParameterABIAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::RoundAndCastToNearestLongOp>::Type>
-from_python<mx::ir::llvm::RoundAndCastToNearestLongOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::IndirectOp>::Type>
-from_python<mx::ir::abi::IndirectOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ColdAttr>::Type>
-from_python<mx::ir::hl::ColdAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ResumeOp>::Type>
-from_python<mx::ir::llvm::ResumeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InitListExpr>::Type>
-from_python<mx::InitListExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FDivOp>::Type>
-from_python<mx::ir::llvm::FDivOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CosOp>::Type>
-from_python<mx::ir::llvm::CosOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CompoundAssignOperator>::Type>
-from_python<mx::CompoundAssignOperator>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnsNonNullAttr>::Type>
-from_python<mx::ReturnsNonNullAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CoroSuspendOp>::Type>
-from_python<mx::ir::llvm::CoroSuspendOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsGenericLoopDirective>::Type>
-from_python<mx::OMPTeamsGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUFlatWorkGroupSizeAttr>::Type>
-from_python<mx::AMDGPUFlatWorkGroupSizeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentNameType>::Type>
-from_python<mx::DependentNameType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDistributeParallelForSimdDirective>::Type>
-from_python<mx::OMPTeamsDistributeParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::XRayLogArgsAttr>::Type>
-from_python<mx::XRayLogArgsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParenListExpr>::Type>
-from_python<mx::ParenListExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PackExpansionExpr>::Type>
-from_python<mx::PackExpansionExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TransparentUnionAttr>::Type>
-from_python<mx::ir::hl::TransparentUnionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SDivOp>::Type>
-from_python<mx::ir::llvm::SDivOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ReturnOp>::Type>
-from_python<mx::ir::llvm::ReturnOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MaskedLoadOp>::Type>
-from_python<mx::ir::llvm::MaskedLoadOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::LoadOp>::Type>
-from_python<mx::ir::memref::LoadOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::PrologueOp>::Type>
-from_python<mx::ir::abi::PrologueOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::GenericAtomicRMWOp>::Type>
-from_python<mx::ir::memref::GenericAtomicRMWOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinType>::Type>
-from_python<mx::BuiltinType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ReturnsTwiceAttr>::Type>
-from_python<mx::ir::hl::ReturnsTwiceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AttributedType>::Type>
-from_python<mx::AttributedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FMulOp>::Type>
-from_python<mx::ir::llvm::FMulOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SExtOp>::Type>
-from_python<mx::ir::llvm::SExtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::MayAliasAttr>::Type>
-from_python<mx::ir::hl::MayAliasAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPThreadPrivateDeclAttr>::Type>
-from_python<mx::OMPThreadPrivateDeclAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareTargetDeclAttr>::Type>
-from_python<mx::OMPDeclareTargetDeclAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAHostAttr>::Type>
-from_python<mx::CUDAHostAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceBuiltinTextureTypeAttr>::Type>
-from_python<mx::CUDADeviceBuiltinTextureTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MaskedStoreOp>::Type>
-from_python<mx::ir::llvm::MaskedStoreOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::abi::RetDirectOp>::Type>
-from_python<mx::ir::abi::RetDirectOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::AllocOp>::Type>
-from_python<mx::ir::memref::AllocOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::UnusedAttr>::Type>
-from_python<mx::ir::hl::UnusedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StaticAssertDecl>::Type>
-from_python<mx::StaticAssertDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaDetectMismatchDecl>::Type>
-from_python<mx::PragmaDetectMismatchDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakAttr>::Type>
-from_python<mx::WeakAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CountLeadingZerosOp>::Type>
-from_python<mx::ir::llvm::CountLeadingZerosOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WarnUnusedAttr>::Type>
-from_python<mx::WarnUnusedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCProtocolExpr>::Type>
-from_python<mx::ObjCProtocolExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftIndirectResultAttr>::Type>
-from_python<mx::SwiftIndirectResultAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMessageExpr>::Type>
-from_python<mx::ObjCMessageExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftContextAttr>::Type>
-from_python<mx::SwiftContextAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FNegOp>::Type>
-from_python<mx::ir::llvm::FNegOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VectorType>::Type>
-from_python<mx::VectorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::UsedAttr>::Type>
-from_python<mx::ir::hl::UsedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingType>::Type>
-from_python<mx::UsingType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MatrixColumnMajorLoadOp>::Type>
-from_python<mx::ir::llvm::MatrixColumnMajorLoadOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnTypestateAttr>::Type>
-from_python<mx::ReturnTypestateAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RestrictAttr>::Type>
-from_python<mx::RestrictAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::GNUInlineAttr>::Type>
-from_python<mx::ir::hl::GNUInlineAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CtPopOp>::Type>
-from_python<mx::ir::llvm::CtPopOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AArch64VectorPcsAttr>::Type>
-from_python<mx::AArch64VectorPcsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ZeroCallUsedRegsAttr>::Type>
-from_python<mx::ZeroCallUsedRegsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CountTrailingZerosOp>::Type>
-from_python<mx::ir::llvm::CountTrailingZerosOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SRemOp>::Type>
-from_python<mx::ir::llvm::SRemOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BlockPointerType>::Type>
-from_python<mx::BlockPointerType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FPExtOp>::Type>
-from_python<mx::ir::llvm::FPExtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFTagAttributedType>::Type>
-from_python<mx::BTFTagAttributedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SIToFPOp>::Type>
-from_python<mx::ir::llvm::SIToFPOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::NoCfCheckAttr>::Type>
-from_python<mx::ir::hl::NoCfCheckAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::Operation>::Type>
-from_python<mx::ir::ll::Operation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::AllocaOp>::Type>
-from_python<mx::ir::memref::AllocaOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LabelStmt>::Type>
-from_python<mx::LabelStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConvertVectorExpr>::Type>
-from_python<mx::ConvertVectorExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MatrixColumnMajorStoreOp>::Type>
-from_python<mx::ir::llvm::MatrixColumnMajorStoreOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr>::Type>
-from_python<mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareVariantAttr>::Type>
-from_python<mx::OMPDeclareVariantAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCaptureNoInitAttr>::Type>
-from_python<mx::OMPCaptureNoInitAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::AllocaOp>::Type>
-from_python<mx::ir::ll::AllocaOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAGlobalAttr>::Type>
-from_python<mx::CUDAGlobalAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXPseudoDestructorExpr>::Type>
-from_python<mx::CXXPseudoDestructorExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceBuiltinSurfaceTypeAttr>::Type>
-from_python<mx::CUDADeviceBuiltinSurfaceTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNullPtrLiteralExpr>::Type>
-from_python<mx::CXXNullPtrLiteralExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AccessSpecDecl>::Type>
-from_python<mx::AccessSpecDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPThreadPrivateDecl>::Type>
-from_python<mx::OMPThreadPrivateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDistributeSimdDirective>::Type>
-from_python<mx::OMPTeamsDistributeSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDistributeParallelForDirective>::Type>
-from_python<mx::OMPTeamsDistributeParallelForDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CmpOp>::Type>
-from_python<mx::ir::hl::CmpOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AvailabilityAttrAttr>::Type>
-from_python<mx::ir::hl::AvailabilityAttrAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::AllocaScopeOp>::Type>
-from_python<mx::ir::memref::AllocaScopeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WarnUnusedResultAttr>::Type>
-from_python<mx::WarnUnusedResultAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExtVectorType>::Type>
-from_python<mx::ExtVectorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoreturnStmt>::Type>
-from_python<mx::CoreturnStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityAttr>::Type>
-from_python<mx::VisibilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedUsingType>::Type>
-from_python<mx::UnresolvedUsingType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXTryStmt>::Type>
-from_python<mx::CXXTryStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftErrorResultAttr>::Type>
-from_python<mx::SwiftErrorResultAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParenExpr>::Type>
-from_python<mx::ParenExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OffsetOfExpr>::Type>
-from_python<mx::OffsetOfExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncContextAttr>::Type>
-from_python<mx::SwiftAsyncContextAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MatrixTransposeOp>::Type>
-from_python<mx::ir::llvm::MatrixTransposeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MatrixMultiplyOp>::Type>
-from_python<mx::ir::llvm::MatrixMultiplyOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::ArgAllocaOp>::Type>
-from_python<mx::ir::ll::ArgAllocaOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::FallthroughAttr>::Type>
-from_python<mx::ir::hl::FallthroughAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentCoawaitExpr>::Type>
-from_python<mx::DependentCoawaitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DbgLabelOp>::Type>
-from_python<mx::ir::llvm::DbgLabelOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DbgDeclareOp>::Type>
-from_python<mx::ir::llvm::DbgDeclareOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::NoProfileInstrumentFunctionAttr>::Type>
-from_python<mx::ir::hl::NoProfileInstrumentFunctionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FPToUIOp>::Type>
-from_python<mx::ir::llvm::FPToUIOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FPToSIOp>::Type>
-from_python<mx::ir::llvm::FPToSIOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ShlOp>::Type>
-from_python<mx::ir::llvm::ShlOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RetainAttr>::Type>
-from_python<mx::RetainAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SelectOp>::Type>
-from_python<mx::ir::llvm::SelectOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::AllocaScopeReturnOp>::Type>
-from_python<mx::ir::memref::AllocaScopeReturnOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RequiresCapabilityAttr>::Type>
-from_python<mx::RequiresCapabilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AArch64SVEPcsAttr>::Type>
-from_python<mx::AArch64SVEPcsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BitIntType>::Type>
-from_python<mx::BitIntType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPMapClauseKind>::Type>
-from_python<mx::OpenMPMapClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPMapModifierKind>::Type>
-from_python<mx::OpenMPMapModifierKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Region>::Type>
-from_python<mx::ir::Region>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPMotionModifierKind>::Type>
-from_python<mx::OpenMPMotionModifierKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Block>::Type>
-from_python<mx::ir::Block>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPNumTasksClauseModifier>::Type>
-from_python<mx::OpenMPNumTasksClauseModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Argument>::Type>
-from_python<mx::ir::Argument>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPOrderClauseKind>::Type>
-from_python<mx::OpenMPOrderClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPOrderClauseModifier>::Type>
-from_python<mx::OpenMPOrderClauseModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VarDecl>::Type>
-from_python<mx::VarDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPReductionClauseModifier>::Type>
-from_python<mx::OpenMPReductionClauseModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPUIToFPOp>::Type>
-from_python<mx::ir::llvm::VPUIToFPOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPScheduleClauseKind>::Type>
-from_python<mx::OpenMPScheduleClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFPToUIOp>::Type>
-from_python<mx::ir::llvm::VPFPToUIOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPScheduleClauseModifier>::Type>
-from_python<mx::OpenMPScheduleClauseModifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtFinallyStmt>::Type>
-from_python<mx::ObjCAtFinallyStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPSeverityClauseKind>::Type>
-from_python<mx::OpenMPSeverityClauseKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadedOperatorKind>::Type>
-from_python<mx::OverloadedOperatorKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Label>::Type>
-from_python<mx::ir::Label>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadsShown>::Type>
-from_python<mx::OverloadsShown>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParameterABI>::Type>
-from_python<mx::ParameterABI>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFPTruncOp>::Type>
-from_python<mx::ir::llvm::VPFPTruncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParenLocsOffsets>::Type>
-from_python<mx::ParenLocsOffsets>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFRemOp>::Type>
-from_python<mx::ir::llvm::VPFRemOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaFPKind>::Type>
-from_python<mx::PragmaFPKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaFloatControlKind>::Type>
-from_python<mx::PragmaFloatControlKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodDecl>::Type>
-from_python<mx::ObjCMethodDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaMSCommentKind>::Type>
-from_python<mx::PragmaMSCommentKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaMSPointersToMembersKind>::Type>
-from_python<mx::PragmaMSPointersToMembersKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludeMacroDirective>::Type>
-from_python<mx::IncludeMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaMSStructKind>::Type>
-from_python<mx::PragmaMSStructKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IBOutletCollectionAttr>::Type>
-from_python<mx::IBOutletCollectionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaSectionFlag>::Type>
-from_python<mx::PragmaSectionFlag>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BreakStmt>::Type>
-from_python<mx::BreakStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFmaOp>::Type>
-from_python<mx::ir::llvm::VPFmaOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PredefinedIdentKind>::Type>
-from_python<mx::PredefinedIdentKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPFSubOp>::Type>
-from_python<mx::ir::llvm::VPFSubOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Qualified>::Type>
-from_python<mx::Qualified>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LikelyAttr>::Type>
-from_python<mx::LikelyAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ClassTemplatePartialSpecializationDecl>::Type>
-from_python<mx::ClassTemplatePartialSpecializationDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RangeExprOffset>::Type>
-from_python<mx::RangeExprOffset>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VarTemplateDecl>::Type>
-from_python<mx::VarTemplateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RangeLocOffset>::Type>
-from_python<mx::RangeLocOffset>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RecordArgPassingKind>::Type>
-from_python<mx::RecordArgPassingKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RedeclarableTemplateDecl>::Type>
-from_python<mx::RedeclarableTemplateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateDecl>::Type>
-from_python<mx::TemplateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtCatchStmt>::Type>
-from_python<mx::ObjCAtCatchStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RefQualifierKind>::Type>
-from_python<mx::RefQualifierKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReservedIdentifierStatus>::Type>
-from_python<mx::ReservedIdentifierStatus>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReservedLiteralSuffixIdStatus>::Type>
-from_python<mx::ReservedLiteralSuffixIdStatus>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCOwnershipAttr>::Type>
-from_python<mx::ObjCOwnershipAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignedAttr>::Type>
-from_python<mx::AlignedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPXorOp>::Type>
-from_python<mx::ir::llvm::VPXorOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SFINAEResponse>::Type>
-from_python<mx::SFINAEResponse>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLMajorVersion>::Type>
-from_python<mx::SYCLMajorVersion>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LifetimeBoundAttr>::Type>
-from_python<mx::LifetimeBoundAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SanitizerOrdinal>::Type>
-from_python<mx::SanitizerOrdinal>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::Symbol>::Type>
-from_python<mx::ir::Symbol>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SelectorLocationsKind>::Type>
-from_python<mx::SelectorLocationsKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ShaderStage>::Type>
-from_python<mx::ShaderStage>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMips16Attr>::Type>
-from_python<mx::NoMips16Attr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPForSimdDirective>::Type>
-from_python<mx::OMPForSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::AttributeKind>::Type>
-from_python<mx::ir::AttributeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HotAttr>::Type>
-from_python<mx::HotAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StrictGuardStackCheckAttr>::Type>
-from_python<mx::StrictGuardStackCheckAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSErrorDomainAttr>::Type>
-from_python<mx::NSErrorDomainAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclaratorDecl>::Type>
-from_python<mx::DeclaratorDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FallThroughAttr>::Type>
-from_python<mx::FallThroughAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPIntToPtrOp>::Type>
-from_python<mx::ir::llvm::VPIntToPtrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ValueDecl>::Type>
-from_python<mx::ValueDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SignReturnAddressKeyKind>::Type>
-from_python<mx::SignReturnAddressKeyKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::BasicBlockOrder>::Type>
-from_python<mx::ir::BasicBlockOrder>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLUniqueStableNameExpr>::Type>
-from_python<mx::SYCLUniqueStableNameExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SignReturnAddressScopeKind>::Type>
-from_python<mx::SignReturnAddressScopeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NamedDecl>::Type>
-from_python<mx::NamedDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXUnresolvedConstructExpr>::Type>
-from_python<mx::CXXUnresolvedConstructExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SignedOverflowBehaviorTy>::Type>
-from_python<mx::SignedOverflowBehaviorTy>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyDecl>::Type>
-from_python<mx::ObjCPropertyDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Attribute>::Type>
-from_python<mx::ir::builtin::Attribute>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::BinLOrOp>::Type>
-from_python<mx::ir::core::BinLOrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMaskedTaskLoopDirective>::Type>
-from_python<mx::OMPMaskedTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SourceLocIdentKind>::Type>
-from_python<mx::SourceLocIdentKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AliasAttr>::Type>
-from_python<mx::AliasAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPFlushDirective>::Type>
-from_python<mx::OMPFlushDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPLShrOp>::Type>
-from_python<mx::ir::llvm::VPLShrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SpecialMemberFlags>::Type>
-from_python<mx::SpecialMemberFlags>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SpecifierKind>::Type>
-from_python<mx::SpecifierKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNSObjectAttr>::Type>
-from_python<mx::ObjCNSObjectAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::TypedAttr>::Type>
-from_python<mx::ir::builtin::TypedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AsmStmt>::Type>
-from_python<mx::AsmStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstNonTypeTemplateParmPackExpr>::Type>
-from_python<mx::SubstNonTypeTemplateParmPackExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GCCAsmStmt>::Type>
-from_python<mx::GCCAsmStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LeafAttr>::Type>
-from_python<mx::LeafAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StackProtectorMode>::Type>
-from_python<mx::StackProtectorMode>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StorageClass>::Type>
-from_python<mx::StorageClass>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StorageDuration>::Type>
-from_python<mx::StorageDuration>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMicroMipsAttr>::Type>
-from_python<mx::NoMicroMipsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::ElementsAttr>::Type>
-from_python<mx::ir::builtin::ElementsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NamespaceDecl>::Type>
-from_python<mx::NamespaceDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignNaturalAttr>::Type>
-from_python<mx::AlignNaturalAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StoredNameKind>::Type>
-from_python<mx::StoredNameKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ClassTemplateSpecializationDecl>::Type>
-from_python<mx::ClassTemplateSpecializationDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IBActionAttr>::Type>
-from_python<mx::IBActionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StrictFPAttr>::Type>
-from_python<mx::StrictFPAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSConsumesSelfAttr>::Type>
-from_python<mx::NSConsumesSelfAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPLoadOp>::Type>
-from_python<mx::ir::llvm::VPLoadOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StoredSpecifierKind>::Type>
-from_python<mx::StoredSpecifierKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeAlignAttr>::Type>
-from_python<mx::CodeAlignAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StrictFlexArraysLevelKind>::Type>
-from_python<mx::StrictFlexArraysLevelKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StringLiteralKind>::Type>
-from_python<mx::StringLiteralKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::ReallocOp>::Type>
-from_python<mx::ir::memref::ReallocOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::AffineMapAttr>::Type>
-from_python<mx::ir::builtin::AffineMapAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SubExpr>::Type>
-from_python<mx::SubExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPExecutableDirective>::Type>
-from_python<mx::OMPExecutableDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPMulOp>::Type>
-from_python<mx::ir::llvm::VPMulOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPMergeMinOp>::Type>
-from_python<mx::ir::llvm::VPMergeMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SyncScope>::Type>
-from_python<mx::SyncScope>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::ArrayAttr>::Type>
-from_python<mx::ir::builtin::ArrayAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SubStmt>::Type>
-from_python<mx::SubStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AbiTagAttr>::Type>
-from_python<mx::AbiTagAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SPtrAttr>::Type>
-from_python<mx::SPtrAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Syntax>::Type>
-from_python<mx::Syntax>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodFamilyAttr>::Type>
-from_python<mx::ObjCMethodFamilyAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExternallyRetainedAttr>::Type>
-from_python<mx::ObjCExternallyRetainedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TagTypeKind>::Type>
-from_python<mx::TagTypeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LayoutVersionAttr>::Type>
-from_python<mx::LayoutVersionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InternalLinkageAttr>::Type>
-from_python<mx::InternalLinkageAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPOrOp>::Type>
-from_python<mx::ir::llvm::VPOrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TQ>::Type>
-from_python<mx::TQ>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::DenseArrayAttr>::Type>
-from_python<mx::ir::builtin::DenseArrayAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInstrumentFunctionAttr>::Type>
-from_python<mx::NoInstrumentFunctionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TailPaddingUseRules>::Type>
-from_python<mx::TailPaddingUseRules>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDestroyAttr>::Type>
-from_python<mx::NoDestroyAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateArgumentDependence>::Type>
-from_python<mx::TemplateArgumentDependence>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXUuidofExpr>::Type>
-from_python<mx::CXXUuidofExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXTypeidExpr>::Type>
-from_python<mx::CXXTypeidExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignMac68kAttr>::Type>
-from_python<mx::AlignMac68kAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquiredAfterAttr>::Type>
-from_python<mx::AcquiredAfterAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ShuffleVectorExpr>::Type>
-from_python<mx::ShuffleVectorExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RequiresExpr>::Type>
-from_python<mx::RequiresExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StdCallAttr>::Type>
-from_python<mx::StdCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsShortCallAttr>::Type>
-from_python<mx::MipsShortCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLResourceBindingAttr>::Type>
-from_python<mx::HLSLResourceBindingAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SpeculativeLoadHardeningAttr>::Type>
-from_python<mx::SpeculativeLoadHardeningAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsInterruptAttr>::Type>
-from_python<mx::MipsInterruptAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateNameDependence>::Type>
-from_python<mx::TemplateNameDependence>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateSpecializationKind>::Type>
-from_python<mx::TemplateSpecializationKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPInteropDirective>::Type>
-from_python<mx::OMPInteropDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnlikelyAttr>::Type>
-from_python<mx::UnlikelyAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCanonicalLoop>::Type>
-from_python<mx::OMPCanonicalLoop>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadableAttr>::Type>
-from_python<mx::OverloadableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::DenseIntOrFPElementsAttr>::Type>
-from_python<mx::ir::builtin::DenseIntOrFPElementsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TextDiagnosticFormat>::Type>
-from_python<mx::TextDiagnosticFormat>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIvarDecl>::Type>
-from_python<mx::ObjCIvarDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ThreadModelKind>::Type>
-from_python<mx::ThreadModelKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeTraitExpr>::Type>
-from_python<mx::TypeTraitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ThreadStorageClassSpecifier>::Type>
-from_python<mx::ThreadStorageClassSpecifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstNonTypeTemplateParmExpr>::Type>
-from_python<mx::SubstNonTypeTemplateParmExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<QualifiedNameRenderOptions>::Type>
-from_python<QualifiedNameRenderOptions>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::DenseStringElementsAttr>::Type>
-from_python<mx::ir::builtin::DenseStringElementsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TrailingAllocKind>::Type>
-from_python<mx::TrailingAllocKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TranslationUnitKind>::Type>
-from_python<mx::TranslationUnitKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TrivialAutoVarInitKind>::Type>
-from_python<mx::TrivialAutoVarInitKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::DenseResourceElementsAttr>::Type>
-from_python<mx::ir::builtin::DenseResourceElementsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeDependence>::Type>
-from_python<mx::TypeDependence>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeAttr>::Type>
-from_python<mx::TypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Ptr64Attr>::Type>
-from_python<mx::Ptr64Attr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeLocClass>::Type>
-from_python<mx::TypeLocClass>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIndependentClassAttr>::Type>
-from_python<mx::ObjCIndependentClassAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExplicitProtocolImplAttr>::Type>
-from_python<mx::ObjCExplicitProtocolImplAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeOfKind>::Type>
-from_python<mx::TypeOfKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPGenericLoopDirective>::Type>
-from_python<mx::OMPGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::DictionaryAttr>::Type>
-from_python<mx::ir::builtin::DictionaryAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPForDirective>::Type>
-from_python<mx::OMPForDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedUsingIfExistsDecl>::Type>
-from_python<mx::UnresolvedUsingIfExistsDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LTOVisibilityPublicAttr>::Type>
-from_python<mx::LTOVisibilityPublicAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IntelOclBiccAttr>::Type>
-from_python<mx::IntelOclBiccAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSAsmStmt>::Type>
-from_python<mx::MSAsmStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WhileStmt>::Type>
-from_python<mx::WhileStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeSpecifierSign>::Type>
-from_python<mx::TypeSpecifierSign>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDuplicateAttr>::Type>
-from_python<mx::NoDuplicateAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPPtrToIntOp>::Type>
-from_python<mx::ir::llvm::VPPtrToIntOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDebugAttr>::Type>
-from_python<mx::NoDebugAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquiredBeforeAttr>::Type>
-from_python<mx::AcquiredBeforeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquireHandleAttr>::Type>
-from_python<mx::AcquireHandleAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPErrorDirective>::Type>
-from_python<mx::OMPErrorDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLShaderAttr>::Type>
-from_python<mx::HLSLShaderAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StandaloneDebugAttr>::Type>
-from_python<mx::StandaloneDebugAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLResourceAttr>::Type>
-from_python<mx::HLSLResourceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SharedTrylockFunctionAttr>::Type>
-from_python<mx::SharedTrylockFunctionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsLongCallAttr>::Type>
-from_python<mx::MipsLongCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Mips16Attr>::Type>
-from_python<mx::Mips16Attr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::FloatAttr>::Type>
-from_python<mx::ir::builtin::FloatAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeSpecifierType>::Type>
-from_python<mx::TypeSpecifierType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RenderScriptKernelAttr>::Type>
-from_python<mx::RenderScriptKernelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeSpecifierWidth>::Type>
-from_python<mx::TypeSpecifierWidth>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLAccessAttr>::Type>
-from_python<mx::OpenCLAccessAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeSpecifiersPipe>::Type>
-from_python<mx::TypeSpecifiersPipe>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceAndOp>::Type>
-from_python<mx::ir::llvm::VPReduceAndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceAddOp>::Type>
-from_python<mx::ir::llvm::VPReduceAddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::IntegerSetAttr>::Type>
-from_python<mx::ir::builtin::IntegerSetAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::IntegerAttr>::Type>
-from_python<mx::ir::builtin::IntegerAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PathKind>::Type>
-from_python<mx::PathKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FileType>::Type>
-from_python<mx::FileType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypedefNameDecl>::Type>
-from_python<mx::TypedefNameDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::CastOp>::Type>
-from_python<mx::ir::memref::CastOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PlusOp>::Type>
-from_python<mx::ir::hl::PlusOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::Int128Type>::Type>
-from_python<mx::ir::hl::Int128Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CompilerName>::Type>
-from_python<mx::CompilerName>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::FunctionType>::Type>
-from_python<mx::ir::builtin::FunctionType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::EmptyDeclOp>::Type>
-from_python<mx::ir::hl::EmptyDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetLanguage>::Type>
-from_python<mx::TargetLanguage>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SMaxOp>::Type>
-from_python<mx::ir::llvm::SMaxOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryTransformType>::Type>
-from_python<mx::UnaryTransformType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SAddWithOverflowOp>::Type>
-from_python<mx::ir::llvm::SAddWithOverflowOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::HalfType>::Type>
-from_python<mx::ir::hl::HalfType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::CollapseShapeOp>::Type>
-from_python<mx::ir::memref::CollapseShapeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::EnumConstantOp>::Type>
-from_python<mx::ir::hl::EnumConstantOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroVAOptArgument>::Type>
-from_python<mx::MacroVAOptArgument>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::IndexType>::Type>
-from_python<mx::ir::builtin::IndexType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::DeallocOp>::Type>
-from_python<mx::ir::memref::DeallocOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BFloat16Type>::Type>
-from_python<mx::ir::hl::BFloat16Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SMinOp>::Type>
-from_python<mx::ir::llvm::SMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::DimOp>::Type>
-from_python<mx::ir::memref::DimOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::IntegerType>::Type>
-from_python<mx::ir::builtin::IntegerType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPShlOp>::Type>
-from_python<mx::ir::llvm::VPShlOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPSelectMinOp>::Type>
-from_python<mx::ir::llvm::VPSelectMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::FloatType>::Type>
-from_python<mx::ir::hl::FloatType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::EnumDeclOp>::Type>
-from_python<mx::ir::hl::EnumDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCProtocolDecl>::Type>
-from_python<mx::ObjCProtocolDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PostDecOp>::Type>
-from_python<mx::ir::hl::PostDecOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::MemRefType>::Type>
-from_python<mx::ir::builtin::MemRefType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DoubleType>::Type>
-from_python<mx::ir::hl::DoubleType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingShadowDecl>::Type>
-from_python<mx::UsingShadowDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PostIncOp>::Type>
-from_python<mx::ir::hl::PostIncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::NoneType>::Type>
-from_python<mx::ir::builtin::NoneType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LongDoubleType>::Type>
-from_python<mx::ir::hl::LongDoubleType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ExprOp>::Type>
-from_python<mx::ir::hl::ExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::DMAStartOp>::Type>
-from_python<mx::ir::memref::DMAStartOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::EnumRefOp>::Type>
-from_python<mx::ir::hl::EnumRefOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CompoundStmt>::Type>
-from_python<mx::CompoundStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::OpaqueType>::Type>
-from_python<mx::ir::builtin::OpaqueType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::Float128Type>::Type>
-from_python<mx::ir::hl::Float128Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SMulWithOverflowOp>::Type>
-from_python<mx::ir::llvm::SMulWithOverflowOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PreDecOp>::Type>
-from_python<mx::ir::hl::PreDecOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroConcatenate>::Type>
-from_python<mx::MacroConcatenate>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ComplexType>::Type>
-from_python<mx::ir::hl::ComplexType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::RankedTensorType>::Type>
-from_python<mx::ir::builtin::RankedTensorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPStoreOp>::Type>
-from_python<mx::ir::llvm::VPStoreOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SSACopyOp>::Type>
-from_python<mx::ir::llvm::SSACopyOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::DMAWaitOp>::Type>
-from_python<mx::ir::memref::DMAWaitOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::TupleType>::Type>
-from_python<mx::ir::builtin::TupleType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PointerType>::Type>
-from_python<mx::ir::hl::PointerType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ElseMacroDirective>::Type>
-from_python<mx::ElseMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PreIncOp>::Type>
-from_python<mx::ir::hl::PreIncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLExportAttr>::Type>
-from_python<mx::DLLExportAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::FCmpOp>::Type>
-from_python<mx::ir::hl::FCmpOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ExtensionOp>::Type>
-from_python<mx::ir::hl::ExtensionOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ArrayType>::Type>
-from_python<mx::ir::hl::ArrayType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::ExpandShapeOp>::Type>
-from_python<mx::ir::memref::ExpandShapeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPStridedLoadOp>::Type>
-from_python<mx::ir::llvm::VPStridedLoadOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSVtorDispAttr>::Type>
-from_python<mx::MSVtorDispAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SShlSatOp>::Type>
-from_python<mx::ir::llvm::SShlSatOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::UnrankedMemRefType>::Type>
-from_python<mx::ir::builtin::UnrankedMemRefType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArtificialAttr>::Type>
-from_python<mx::ArtificialAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PredefinedExprOp>::Type>
-from_python<mx::ir::hl::PredefinedExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDesignatedInitializerAttr>::Type>
-from_python<mx::ObjCDesignatedInitializerAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitValueInitExpr>::Type>
-from_python<mx::ImplicitValueInitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::ExtractAlignedPointerAsIndexOp>::Type>
-from_python<mx::ir::memref::ExtractAlignedPointerAsIndexOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstAttr>::Type>
-from_python<mx::ConstAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::VectorType>::Type>
-from_python<mx::ir::hl::VectorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstTemplateTypeParmType>::Type>
-from_python<mx::SubstTemplateTypeParmType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftNewTypeAttr>::Type>
-from_python<mx::SwiftNewTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::UnrankedTensorType>::Type>
-from_python<mx::ir::builtin::UnrankedTensorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnoseIfAttr>::Type>
-from_python<mx::DiagnoseIfAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPSubOp>::Type>
-from_python<mx::ir::llvm::VPSubOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPStridedStoreOp>::Type>
-from_python<mx::ir::llvm::VPStridedStoreOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DecayedType>::Type>
-from_python<mx::ir::hl::DecayedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SSubSatOp>::Type>
-from_python<mx::ir::llvm::SSubSatOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::ExtractStridedMetadataOp>::Type>
-from_python<mx::ir::memref::ExtractStridedMetadataOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BlocksAttr>::Type>
-from_python<mx::BlocksAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSConsumedAttr>::Type>
-from_python<mx::OSConsumedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::VectorType>::Type>
-from_python<mx::ir::builtin::VectorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FileScopeAsmDecl>::Type>
-from_python<mx::FileScopeAsmDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConditionalOperator>::Type>
-from_python<mx::ConditionalOperator>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PreferredAlignOfExprOp>::Type>
-from_python<mx::ir::hl::PreferredAlignOfExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VectorCallAttr>::Type>
-from_python<mx::VectorCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AttributedType>::Type>
-from_python<mx::ir::hl::AttributedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UPtrAttr>::Type>
-from_python<mx::UPtrAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSPropertyRefExpr>::Type>
-from_python<mx::MSPropertyRefExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeTagForDatatypeAttr>::Type>
-from_python<mx::TypeTagForDatatypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConversionDecl>::Type>
-from_python<mx::CXXConversionDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroStringify>::Type>
-from_python<mx::MacroStringify>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SinOp>::Type>
-from_python<mx::ir::llvm::SinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BaseUsingDecl>::Type>
-from_python<mx::BaseUsingDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::UnrealizedConversionCastOp>::Type>
-from_python<mx::ir::builtin::UnrealizedConversionCastOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SSubWithOverflowOp>::Type>
-from_python<mx::ir::llvm::SSubWithOverflowOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::FieldDeclOp>::Type>
-from_python<mx::ir::hl::FieldDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AdjustedType>::Type>
-from_python<mx::ir::hl::AdjustedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FinalAttr>::Type>
-from_python<mx::FinalAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExtVectorElementExpr>::Type>
-from_python<mx::ExtVectorElementExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCImplementationDecl>::Type>
-from_python<mx::ObjCImplementationDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RealOp>::Type>
-from_python<mx::ir::hl::RealOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::PreferredAlignOfTypeOp>::Type>
-from_python<mx::ir::hl::PreferredAlignOfTypeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ElseIfNotDefinedMacroDirective>::Type>
-from_python<mx::ElseIfNotDefinedMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::GetGlobalOp>::Type>
-from_python<mx::ir::memref::GetGlobalOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CountedByAttr>::Type>
-from_python<mx::CountedByAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCImplDecl>::Type>
-from_python<mx::ObjCImplDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ReferenceType>::Type>
-from_python<mx::ir::hl::ReferenceType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelGenericLoopDirective>::Type>
-from_python<mx::OMPParallelGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::SqrtOp>::Type>
-from_python<mx::ir::llvm::SqrtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSStructAttr>::Type>
-from_python<mx::MSStructAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SEHFinallyStmt>::Type>
-from_python<mx::SEHFinallyStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::Attribute>::Type>
-from_python<mx::ir::llvm::Attribute>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmNewAttr>::Type>
-from_python<mx::ArmNewAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCClassStubAttr>::Type>
-from_python<mx::ObjCClassStubAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CommonAttr>::Type>
-from_python<mx::CommonAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ForOp>::Type>
-from_python<mx::ir::hl::ForOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstTemplateTypeParmPackType>::Type>
-from_python<mx::SubstTemplateTypeParmPackType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::FileScopeAsmOp>::Type>
-from_python<mx::ir::hl::FileScopeAsmOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::GlobalOp>::Type>
-from_python<mx::ir::memref::GlobalOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TypeOfExprType>::Type>
-from_python<mx::ir::hl::TypeOfExprType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPTruncOp>::Type>
-from_python<mx::ir::llvm::VPTruncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftNameAttr>::Type>
-from_python<mx::SwiftNameAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::CConvAttr>::Type>
-from_python<mx::ir::llvm::CConvAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExplicitCastExpr>::Type>
-from_python<mx::ExplicitCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDynamicCastExpr>::Type>
-from_python<mx::CXXDynamicCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NonNullAttr>::Type>
-from_python<mx::NonNullAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFDeclTagAttr>::Type>
-from_python<mx::BTFDeclTagAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::FuncOp>::Type>
-from_python<mx::ir::hl::FuncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TypeOfTypeType>::Type>
-from_python<mx::ir::hl::TypeOfTypeType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnoseAsBuiltinAttr>::Type>
-from_python<mx::DiagnoseAsBuiltinAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VecTypeHintAttr>::Type>
-from_python<mx::VecTypeHintAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ComdatAttr>::Type>
-from_python<mx::ir::llvm::ComdatAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RecordMemberOp>::Type>
-from_python<mx::ir::hl::RecordMemberOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeNullableResultAttr>::Type>
-from_python<mx::TypeNullableResultAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::MemorySpaceCastOp>::Type>
-from_python<mx::ir::memref::MemorySpaceCastOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AutoType>::Type>
-from_python<mx::ir::hl::AutoType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPUDivOp>::Type>
-from_python<mx::ir::llvm::VPUDivOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CStyleCastExpr>::Type>
-from_python<mx::CStyleCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgedCastExpr>::Type>
-from_python<mx::ObjCBridgedCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TryAcquireCapabilityAttr>::Type>
-from_python<mx::TryAcquireCapabilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LinkageAttr>::Type>
-from_python<mx::ir::llvm::LinkageAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GNUNullExpr>::Type>
-from_python<mx::GNUNullExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FastCallAttr>::Type>
-from_python<mx::FastCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::PrefetchOp>::Type>
-from_python<mx::ir::memref::PrefetchOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroExpansion>::Type>
-from_python<mx::MacroExpansion>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::StackRestoreOp>::Type>
-from_python<mx::ir::llvm::StackRestoreOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AtomicType>::Type>
-from_python<mx::ir::hl::AtomicType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroParameterSubstitution>::Type>
-from_python<mx::MacroParameterSubstitution>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::RankOp>::Type>
-from_python<mx::ir::memref::RankOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroWrapperAttr>::Type>
-from_python<mx::CoroWrapperAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FramePointerKindAttr>::Type>
-from_python<mx::ir::llvm::FramePointerKindAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RemFOp>::Type>
-from_python<mx::ir::hl::RemFOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RemFAssignOp>::Type>
-from_python<mx::ir::hl::RemFAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ElseIfDefinedMacroDirective>::Type>
-from_python<mx::ElseIfDefinedMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::StackSaveOp>::Type>
-from_python<mx::ir::llvm::StackSaveOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::Operation>::Type>
-from_python<mx::ir::hl::Operation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSP430InterruptAttr>::Type>
-from_python<mx::MSP430InterruptAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RefOp>::Type>
-from_python<mx::ir::hl::RefOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBoxableAttr>::Type>
-from_python<mx::ObjCBoxableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayInitIndexExpr>::Type>
-from_python<mx::ArrayInitIndexExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoEscapeAttr>::Type>
-from_python<mx::NoEscapeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ColdAttr>::Type>
-from_python<mx::ColdAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmLocallyStreamingAttr>::Type>
-from_python<mx::ArmLocallyStreamingAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeModelAttr>::Type>
-from_python<mx::CodeModelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86NoCfCheckAttr>::Type>
-from_python<mx::AnyX86NoCfCheckAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReferenceType>::Type>
-from_python<mx::ReferenceType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LifetimeExtendedTemporaryDecl>::Type>
-from_python<mx::LifetimeExtendedTemporaryDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EmptyDecl>::Type>
-from_python<mx::EmptyDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftImportPropertyAsAccessorsAttr>::Type>
-from_python<mx::SwiftImportPropertyAsAccessorsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopInterleaveAttr>::Type>
-from_python<mx::ir::llvm::LoopInterleaveAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::FuncRefOp>::Type>
-from_python<mx::ir::hl::FuncRefOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftErrorAttr>::Type>
-from_python<mx::SwiftErrorAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDeductionGuideDecl>::Type>
-from_python<mx::CXXDeductionGuideDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSConsumedAttr>::Type>
-from_python<mx::NSConsumedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareMapperDecl>::Type>
-from_python<mx::OMPDeclareMapperDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::StepVectorOp>::Type>
-from_python<mx::ir::llvm::StepVectorOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CalledOnceAttr>::Type>
-from_python<mx::CalledOnceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FixedPointLiteral>::Type>
-from_python<mx::FixedPointLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExpressionTraitExpr>::Type>
-from_python<mx::ExpressionTraitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AccessSpecifierOp>::Type>
-from_python<mx::ir::hl::AccessSpecifierOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BPFPreserveStaticOffsetAttr>::Type>
-from_python<mx::BPFPreserveStaticOffsetAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailableOnlyInDefaultEvalMethodAttr>::Type>
-from_python<mx::AvailableOnlyInDefaultEvalMethodAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DestructorAttr>::Type>
-from_python<mx::DestructorAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclOrStmtAttr>::Type>
-from_python<mx::DeclOrStmtAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopUnrollAttr>::Type>
-from_python<mx::ir::llvm::LoopUnrollAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VecReturnAttr>::Type>
-from_python<mx::VecReturnAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeNullableAttr>::Type>
-from_python<mx::TypeNullableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingIfExistsAttr>::Type>
-from_python<mx::UsingIfExistsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeNonNullAttr>::Type>
-from_python<mx::TypeNonNullAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMaskedTaskLoopDirective>::Type>
-from_python<mx::OMPParallelMaskedTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelForSimdDirective>::Type>
-from_python<mx::OMPParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyImplDecl>::Type>
-from_python<mx::ObjCPropertyImplDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPURemOp>::Type>
-from_python<mx::ir::llvm::VPURemOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypedefType>::Type>
-from_python<mx::TypedefType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AddFAssignOp>::Type>
-from_python<mx::ir::hl::AddFAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::GenericAssocExprOp>::Type>
-from_python<mx::ir::hl::GenericAssocExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::TrapOp>::Type>
-from_python<mx::ir::llvm::TrapOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopUnrollAndJamAttr>::Type>
-from_python<mx::ir::llvm::LoopUnrollAndJamAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TrivialABIAttr>::Type>
-from_python<mx::TrivialABIAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ThreadLocalAddressOp>::Type>
-from_python<mx::ir::llvm::ThreadLocalAddressOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ThisCallAttr>::Type>
-from_python<mx::ThisCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AddFOp>::Type>
-from_python<mx::ir::hl::AddFOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RemSOp>::Type>
-from_python<mx::ir::hl::RemSOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExclusiveTrylockFunctionAttr>::Type>
-from_python<mx::ExclusiveTrylockFunctionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RemSAssignOp>::Type>
-from_python<mx::ir::hl::RemSAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ErrorAttr>::Type>
-from_python<mx::ErrorAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::ReinterpretCastOp>::Type>
-from_python<mx::ir::memref::ReinterpretCastOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroReturnTypeAttr>::Type>
-from_python<mx::CoroReturnTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroLifetimeBoundAttr>::Type>
-from_python<mx::CoroLifetimeBoundAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCForCollectionStmt>::Type>
-from_python<mx::ObjCForCollectionStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopLICMAttr>::Type>
-from_python<mx::ir::llvm::LoopLICMAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNamedCastExpr>::Type>
-from_python<mx::CXXNamedCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroArgument>::Type>
-from_python<mx::MacroArgument>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConstCastExpr>::Type>
-from_python<mx::CXXConstCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RValueReferenceType>::Type>
-from_python<mx::RValueReferenceType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedType>::Type>
-from_python<mx::QualifiedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::GenericSelectionExprOp>::Type>
-from_python<mx::ir::hl::GenericSelectionExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPReferencedVarAttr>::Type>
-from_python<mx::OMPReferencedVarAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSNoVTableAttr>::Type>
-from_python<mx::MSNoVTableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VariableArrayType>::Type>
-from_python<mx::VariableArrayType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCaptureKindAttr>::Type>
-from_python<mx::OMPCaptureKindAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeSegAttr>::Type>
-from_python<mx::CodeSegAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmBuiltinAliasAttr>::Type>
-from_python<mx::ArmBuiltinAliasAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CmseNSEntryAttr>::Type>
-from_python<mx::CmseNSEntryAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArcWeakrefUnavailableAttr>::Type>
-from_python<mx::ArcWeakrefUnavailableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSConstexprAttr>::Type>
-from_python<mx::MSConstexprAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ElseIfMacroDirective>::Type>
-from_python<mx::ElseIfMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IfNotDefinedMacroDirective>::Type>
-from_python<mx::IfNotDefinedMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayType>::Type>
-from_python<mx::ArrayType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::StoreOp>::Type>
-from_python<mx::ir::memref::StoreOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::ReshapeOp>::Type>
-from_python<mx::ir::memref::ReshapeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftImportAsNonGenericAttr>::Type>
-from_python<mx::SwiftImportAsNonGenericAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinBitCastExpr>::Type>
-from_python<mx::BuiltinBitCastExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftCallAttr>::Type>
-from_python<mx::SwiftCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CallExpr>::Type>
-from_python<mx::CallExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UAddSatOp>::Type>
-from_python<mx::ir::llvm::UAddSatOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopPipelineAttr>::Type>
-from_python<mx::ir::llvm::LoopPipelineAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GenericSelectionExpr>::Type>
-from_python<mx::GenericSelectionExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionParmPackExpr>::Type>
-from_python<mx::FunctionParmPackExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IFuncAttr>::Type>
-from_python<mx::IFuncAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinAliasAttr>::Type>
-from_python<mx::BuiltinAliasAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedUsingTypenameDecl>::Type>
-from_python<mx::UnresolvedUsingTypenameDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BPFPreserveAccessIndexAttr>::Type>
-from_python<mx::BPFPreserveAccessIndexAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailabilityAttr>::Type>
-from_python<mx::AvailabilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeprecatedAttr>::Type>
-from_python<mx::DeprecatedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AlwaysInlineAttr>::Type>
-from_python<mx::AlwaysInlineAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeNullUnspecifiedAttr>::Type>
-from_python<mx::TypeNullUnspecifiedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UuidAttr>::Type>
-from_python<mx::UuidAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsedAttr>::Type>
-from_python<mx::UsedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ThreadAttr>::Type>
-from_python<mx::ThreadAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopPeeledAttr>::Type>
-from_python<mx::ir::llvm::LoopPeeledAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPZExtOp>::Type>
-from_python<mx::ir::llvm::VPZExtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::GlobalRefOp>::Type>
-from_python<mx::ir::hl::GlobalRefOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AddIAssignOp>::Type>
-from_python<mx::ir::hl::AddIAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AddIOp>::Type>
-from_python<mx::ir::hl::AddIOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RemUOp>::Type>
-from_python<mx::ir::hl::RemUOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RemUAssignOp>::Type>
-from_python<mx::ir::hl::RemUAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UAddWithOverflowOp>::Type>
-from_python<mx::ir::llvm::UAddWithOverflowOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AbstractConditionalOperator>::Type>
-from_python<mx::AbstractConditionalOperator>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TransparentUnionAttr>::Type>
-from_python<mx::TransparentUnionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BinaryConditionalOperator>::Type>
-from_python<mx::BinaryConditionalOperator>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TestTypestateAttr>::Type>
-from_python<mx::TestTypestateAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopUnswitchAttr>::Type>
-from_python<mx::ir::llvm::LoopUnswitchAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExcludeFromExplicitInstantiationAttr>::Type>
-from_python<mx::ExcludeFromExplicitInstantiationAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumExtensibilityAttr>::Type>
-from_python<mx::EnumExtensibilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExportDecl>::Type>
-from_python<mx::ExportDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroOnlyDestroyWhenCompleteAttr>::Type>
-from_python<mx::CoroOnlyDestroyWhenCompleteAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LValueReferenceType>::Type>
-from_python<mx::LValueReferenceType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroDisableLifetimeBoundAttr>::Type>
-from_python<mx::CoroDisableLifetimeBoundAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PointerType>::Type>
-from_python<mx::PointerType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroSubstitution>::Type>
-from_python<mx::MacroSubstitution>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::GotoStmtOp>::Type>
-from_python<mx::ir::hl::GotoStmtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::LoopAnnotationAttr>::Type>
-from_python<mx::ir::llvm::LoopAnnotationAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::TransposeOp>::Type>
-from_python<mx::ir::memref::TransposeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::DIExpressionElemAttr>::Type>
-from_python<mx::ir::llvm::DIExpressionElemAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UMaxOp>::Type>
-from_python<mx::ir::llvm::UMaxOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VaCopyOp>::Type>
-from_python<mx::ir::llvm::VaCopyOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::UBSanTrapOp>::Type>
-from_python<mx::ir::llvm::UBSanTrapOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AddrLabelExprOp>::Type>
-from_python<mx::ir::hl::AddrLabelExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ReturnOp>::Type>
-from_python<mx::ir::hl::ReturnOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::memref::ViewOp>::Type>
-from_python<mx::ir::memref::ViewOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSPropertySubscriptExpr>::Type>
-from_python<mx::MSPropertySubscriptExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VaEndOp>::Type>
-from_python<mx::ir::llvm::VaEndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSInheritanceAttr>::Type>
-from_python<mx::MSInheritanceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LambdaExpr>::Type>
-from_python<mx::LambdaExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareSimdDeclAttr>::Type>
-from_python<mx::OMPDeclareSimdDeclAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArgumentWithTypeTagAttr>::Type>
-from_python<mx::ArgumentWithTypeTagAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclarativeDirectiveValueDecl>::Type>
-from_python<mx::OMPDeclarativeDirectiveValueDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSAllocatorAttr>::Type>
-from_python<mx::MSAllocatorAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConstructorDecl>::Type>
-from_python<mx::CXXConstructorDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtDefsFieldDecl>::Type>
-from_python<mx::ObjCAtDefsFieldDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnnotateAttrSpelling>::Type>
-from_python<mx::AnnotateAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnnotateTypeAttrSpelling>::Type>
-from_python<mx::AnnotateTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCTypeParamDecl>::Type>
-from_python<mx::ObjCTypeParamDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86InterruptAttrSpelling>::Type>
-from_python<mx::AnyX86InterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86NoCallerSavedRegistersAttrSpelling>::Type>
-from_python<mx::AnyX86NoCallerSavedRegistersAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedStmtId>::Type>
-from_python<PackedStmtId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::BrOp>::Type>
-from_python<mx::ir::ll::BrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86NoCfCheckAttrSpelling>::Type>
-from_python<mx::AnyX86NoCfCheckAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArcWeakrefUnavailableAttrSpelling>::Type>
-from_python<mx::ArcWeakrefUnavailableAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AsmLabelAttr>::Type>
-from_python<mx::ir::hl::AsmLabelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArgumentWithTypeTagAttrSpelling>::Type>
-from_python<mx::ArgumentWithTypeTagAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinOrOp>::Type>
-from_python<mx::ir::hl::BinOrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmBuiltinAliasAttrSpelling>::Type>
-from_python<mx::ArmBuiltinAliasAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmMveStrictPolymorphismAttrSpelling>::Type>
-from_python<mx::ArmMveStrictPolymorphismAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArtificialAttrSpelling>::Type>
-from_python<mx::ArtificialAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AsmLabelAttrSpelling>::Type>
-from_python<mx::AsmLabelAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::ConcatOp>::Type>
-from_python<mx::ir::ll::ConcatOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AssertCapabilityAttrSpelling>::Type>
-from_python<mx::AssertCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ModeAttr>::Type>
-from_python<mx::ir::hl::ModeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AssumeAlignedAttrSpelling>::Type>
-from_python<mx::AssumeAlignedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedCompilationId>::Type>
-from_python<PackedCompilationId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AssumptionAttrSpelling>::Type>
-from_python<mx::AssumptionAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TypeOfExprOp>::Type>
-from_python<mx::ir::hl::TypeOfExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AtomicExprAtomicOp>::Type>
-from_python<mx::AtomicExprAtomicOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VScaleRangeAttr>::Type>
-from_python<mx::ir::llvm::VScaleRangeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailabilityAttrSpelling>::Type>
-from_python<mx::AvailabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::ModuleOp>::Type>
-from_python<mx::ir::builtin::ModuleOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailableOnlyInDefaultEvalMethodAttrSpelling>::Type>
-from_python<mx::AvailableOnlyInDefaultEvalMethodAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BuiltinAttr>::Type>
-from_python<mx::ir::hl::BuiltinAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BPFPreserveAccessIndexAttrSpelling>::Type>
-from_python<mx::BPFPreserveAccessIndexAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BPFPreserveStaticOffsetAttrSpelling>::Type>
-from_python<mx::BPFPreserveStaticOffsetAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::TargetFeaturesAttr>::Type>
-from_python<mx::ir::llvm::TargetFeaturesAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFDeclTagAttrSpelling>::Type>
-from_python<mx::BTFDeclTagAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Operation>::Type>
-from_python<mx::ir::builtin::Operation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFTypeTagAttrSpelling>::Type>
-from_python<mx::BTFTypeTagAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::CondBrOp>::Type>
-from_python<mx::ir::ll::CondBrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BlocksAttrBlockType>::Type>
-from_python<mx::BlocksAttrBlockType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BlocksAttrSpelling>::Type>
-from_python<mx::BlocksAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinAliasAttrSpelling>::Type>
-from_python<mx::BuiltinAliasAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinTypeKind>::Type>
-from_python<mx::BuiltinTypeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TypeYieldOp>::Type>
-from_python<mx::ir::hl::TypeYieldOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AllocAlignAttr>::Type>
-from_python<mx::ir::hl::AllocAlignAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CDeclAttrSpelling>::Type>
-from_python<mx::CDeclAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFAuditedTransferAttrSpelling>::Type>
-from_python<mx::CFAuditedTransferAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::IntegerOverflowFlagsAttr>::Type>
-from_python<mx::ir::llvm::IntegerOverflowFlagsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinShlAssignOp>::Type>
-from_python<mx::ir::hl::BinShlAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::CondScopeRetOp>::Type>
-from_python<mx::ir::ll::CondScopeRetOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AllocSizeAttr>::Type>
-from_python<mx::ir::hl::AllocSizeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FastmathFlagsAttr>::Type>
-from_python<mx::ir::llvm::FastmathFlagsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::Type>::Type>
-from_python<mx::ir::llvm::Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DefineMacroDirective>::Type>
-from_python<mx::DefineMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::UnionDeclOp>::Type>
-from_python<mx::ir::hl::UnionDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroDirective>::Type>
-from_python<mx::MacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::DeprecatedAttr>::Type>
-from_python<mx::ir::hl::DeprecatedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::ExtractOp>::Type>
-from_python<mx::ir::ll::ExtractOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeAliasTemplateDecl>::Type>
-from_python<mx::TypeAliasTemplateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinShlOp>::Type>
-from_python<mx::ir::hl::BinShlOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFConsumedAttrSpelling>::Type>
-from_python<mx::CFConsumedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFGuardAttrGuardArg>::Type>
-from_python<mx::CFGuardAttrGuardArg>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFGuardAttrSpelling>::Type>
-from_python<mx::CFGuardAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFICanonicalJumpTableAttrSpelling>::Type>
-from_python<mx::CFICanonicalJumpTableAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::MaxFieldAlignmentAttr>::Type>
-from_python<mx::ir::hl::MaxFieldAlignmentAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ArrayType>::Type>
-from_python<mx::ir::llvm::ArrayType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFReturnsNotRetainedAttrSpelling>::Type>
-from_python<mx::CFReturnsNotRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFReturnsRetainedAttrSpelling>::Type>
-from_python<mx::CFReturnsRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFUnknownTransferAttrSpelling>::Type>
-from_python<mx::CFUnknownTransferAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CPUDispatchAttrSpelling>::Type>
-from_python<mx::CPUDispatchAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::UnreachableOp>::Type>
-from_python<mx::ir::hl::UnreachableOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CPUSpecificAttrSpelling>::Type>
-from_python<mx::CPUSpecificAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAConstantAttrSpelling>::Type>
-from_python<mx::CUDAConstantAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::VisibilityAttr>::Type>
-from_python<mx::ir::hl::VisibilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceAttrSpelling>::Type>
-from_python<mx::CUDADeviceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::InitializeVarOp>::Type>
-from_python<mx::ir::ll::InitializeVarOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FunctionType>::Type>
-from_python<mx::ir::llvm::FunctionType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling>::Type>
-from_python<mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceBuiltinTextureTypeAttrSpelling>::Type>
-from_python<mx::CUDADeviceBuiltinTextureTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinXorAssignOp>::Type>
-from_python<mx::ir::hl::BinXorAssignOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::VAArgExprOp>::Type>
-from_python<mx::ir::hl::VAArgExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAGlobalAttrSpelling>::Type>
-from_python<mx::CUDAGlobalAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAHostAttrSpelling>::Type>
-from_python<mx::CUDAHostAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentSizedExtVectorType>::Type>
-from_python<mx::DependentSizedExtVectorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::AssumeAlignedAttr>::Type>
-from_python<mx::ir::hl::AssumeAlignedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BlockDecl>::Type>
-from_python<mx::BlockDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDALaunchBoundsAttrSpelling>::Type>
-from_python<mx::CUDALaunchBoundsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDASharedAttrSpelling>::Type>
-from_python<mx::CUDASharedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXX11NoReturnAttrSpelling>::Type>
-from_python<mx::CXX11NoReturnAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXRecordDeclLambdaDependencyKind>::Type>
-from_python<mx::CXXRecordDeclLambdaDependencyKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenContext>::Type>
-from_python<mx::TokenContext>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CallExprADLCallKind>::Type>
-from_python<mx::CallExprADLCallKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CVQualifiersAttr>::Type>
-from_python<mx::ir::hl::CVQualifiersAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::PointerType>::Type>
-from_python<mx::ir::llvm::PointerType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CallableWhenAttrConsumedState>::Type>
-from_python<mx::CallableWhenAttrConsumedState>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::LoadOp>::Type>
-from_python<mx::ir::ll::LoadOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PackedAttr>::Type>
-from_python<mx::PackedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::InlineScopeOp>::Type>
-from_python<mx::ir::ll::InlineScopeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CallableWhenAttrSpelling>::Type>
-from_python<mx::CallableWhenAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinXorOp>::Type>
-from_python<mx::ir::hl::BinXorOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ValueYieldOp>::Type>
-from_python<mx::ir::hl::ValueYieldOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CallbackAttrSpelling>::Type>
-from_python<mx::CallbackAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PreferredTypeAttr>::Type>
-from_python<mx::PreferredTypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceAttr>::Type>
-from_python<mx::CUDADeviceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FixedVectorType>::Type>
-from_python<mx::ir::llvm::FixedVectorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CalledOnceAttrSpelling>::Type>
-from_python<mx::CalledOnceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CapabilityAttrSpelling>::Type>
-from_python<mx::CapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedStmtVariableCaptureKind>::Type>
-from_python<mx::CapturedStmtVariableCaptureKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::UCVQualifiersAttr>::Type>
-from_python<mx::ir::hl::UCVQualifiersAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CarriesDependencyAttrSpelling>::Type>
-from_python<mx::CarriesDependencyAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPAllocateDeclAttr>::Type>
-from_python<mx::OMPAllocateDeclAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CleanupAttrSpelling>::Type>
-from_python<mx::CleanupAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLGroupSharedAddressSpaceAttr>::Type>
-from_python<mx::HLSLGroupSharedAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CompoundLiteralExpr>::Type>
-from_python<mx::CompoundLiteralExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SetTypestateAttr>::Type>
-from_python<mx::SetTypestateAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::FuncOp>::Type>
-from_python<mx::ir::ll::FuncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EmptyTokenTreeNode>::Type>
-from_python<mx::EmptyTokenTreeNode>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::WhileOp>::Type>
-from_python<mx::ir::hl::WhileOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ScalableVectorType>::Type>
-from_python<mx::ir::llvm::ScalableVectorType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeAlignAttrSpelling>::Type>
-from_python<mx::CodeAlignAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::VarDeclOp>::Type>
-from_python<mx::ir::hl::VarDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeModelAttrSpelling>::Type>
-from_python<mx::CodeModelAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ColdAttrSpelling>::Type>
-from_python<mx::ColdAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CommonAttrSpelling>::Type>
-from_python<mx::CommonAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BreakOp>::Type>
-from_python<mx::ir::hl::BreakOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CVRQualifiersAttr>::Type>
-from_python<mx::ir::hl::CVRQualifiersAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BinaryCondOp>::Type>
-from_python<mx::ir::hl::BinaryCondOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstAttrSpelling>::Type>
-from_python<mx::ConstAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AtomicType>::Type>
-from_python<mx::AtomicType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FriendDecl>::Type>
-from_python<mx::FriendDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstInitAttrSpelling>::Type>
-from_python<mx::ConstInitAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLNumThreadsAttr>::Type>
-from_python<mx::HLSLNumThreadsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstructorAttrSpelling>::Type>
-from_python<mx::ConstructorAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::TargetExtType>::Type>
-from_python<mx::ir::llvm::TargetExtType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAttrConsumedState>::Type>
-from_python<mx::ConsumableAttrConsumedState>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentBitIntType>::Type>
-from_python<mx::DependentBitIntType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAttrSpelling>::Type>
-from_python<mx::ConsumableAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAutoCastAttrSpelling>::Type>
-from_python<mx::ConsumableAutoCastAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReqdWorkGroupSizeAttr>::Type>
-from_python<mx::ReqdWorkGroupSizeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::OffsetOfNodeAttr>::Type>
-from_python<mx::ir::hl::OffsetOfNodeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableSetOnReadAttrSpelling>::Type>
-from_python<mx::ConsumableSetOnReadAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::Type>::Type>
-from_python<mx::ir::hl::Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDefaultArgExpr>::Type>
-from_python<mx::CXXDefaultArgExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConvergentAttrSpelling>::Type>
-from_python<mx::ConvergentAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroDisableLifetimeBoundAttrSpelling>::Type>
-from_python<mx::CoroDisableLifetimeBoundAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AShrOp>::Type>
-from_python<mx::ir::llvm::AShrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroLifetimeBoundAttrSpelling>::Type>
-from_python<mx::CoroLifetimeBoundAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::Operation>::Type>
-from_python<mx::ir::llvm::Operation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroOnlyDestroyWhenCompleteAttrSpelling>::Type>
-from_python<mx::CoroOnlyDestroyWhenCompleteAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroReturnTypeAttrSpelling>::Type>
-from_python<mx::CoroReturnTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroWrapperAttrSpelling>::Type>
-from_python<mx::CoroWrapperAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OwnershipAttr>::Type>
-from_python<mx::OwnershipAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPArrayShapingExpr>::Type>
-from_python<mx::OMPArrayShapingExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LinkageSpecDecl>::Type>
-from_python<mx::LinkageSpecDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CountedByAttrSpelling>::Type>
-from_python<mx::CountedByAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AddOp>::Type>
-from_python<mx::ir::llvm::AddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLExportAttrSpelling>::Type>
-from_python<mx::DLLExportAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLImportAttrSpelling>::Type>
-from_python<mx::DLLImportAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclFriendObjectKind>::Type>
-from_python<mx::DeclFriendObjectKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAConstantAttr>::Type>
-from_python<mx::CUDAConstantAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCapturedExprDecl>::Type>
-from_python<mx::OMPCapturedExprDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclIdentifierNamespace>::Type>
-from_python<mx::DeclIdentifierNamespace>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::StructGEPOp>::Type>
-from_python<mx::ir::ll::StructGEPOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BuiltinBitCastOp>::Type>
-from_python<mx::ir::hl::BuiltinBitCastOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RecordType>::Type>
-from_python<mx::ir::hl::RecordType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclModuleOwnershipKind>::Type>
-from_python<mx::DeclModuleOwnershipKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PreferredNameAttr>::Type>
-from_python<mx::PreferredNameAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclObjCDeclQualifier>::Type>
-from_python<mx::DeclObjCDeclQualifier>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CmseNSCallAttr>::Type>
-from_python<mx::CmseNSCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SentinelAttr>::Type>
-from_python<mx::SentinelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NotTailCalledAttr>::Type>
-from_python<mx::NotTailCalledAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::Attribute>::Type>
-from_python<mx::ir::core::Attribute>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IncompleteArrayType>::Type>
-from_python<mx::IncompleteArrayType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXThrowExpr>::Type>
-from_python<mx::CXXThrowExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXStdInitializerListExpr>::Type>
-from_python<mx::CXXStdInitializerListExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::EnumType>::Type>
-from_python<mx::ir::hl::EnumType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeprecatedAttrSpelling>::Type>
-from_python<mx::DeprecatedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DestructorAttrSpelling>::Type>
-from_python<mx::DestructorAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLAnnotationAttr>::Type>
-from_python<mx::HLSLAnnotationAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentAddressSpaceType>::Type>
-from_python<mx::DependentAddressSpaceType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::BooleanAttr>::Type>
-from_python<mx::ir::core::BooleanAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BuiltinTypesCompatiblePOp>::Type>
-from_python<mx::ir::hl::BuiltinTypesCompatiblePOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclKind>::Type>
-from_python<mx::DeclKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::ScopeOp>::Type>
-from_python<mx::ir::ll::ScopeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::ReturnOp>::Type>
-from_python<mx::ir::ll::ReturnOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnoseAsBuiltinAttrSpelling>::Type>
-from_python<mx::DiagnoseAsBuiltinAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::TypedefType>::Type>
-from_python<mx::ir::hl::TypedefType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnoseIfAttrDiagnosticType>::Type>
-from_python<mx::DiagnoseIfAttrDiagnosticType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DisableSanitizerInstrumentationAttrSpelling>::Type>
-from_python<mx::DisableSanitizerInstrumentationAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DisableTailCallsAttrSpelling>::Type>
-from_python<mx::DisableTailCallsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCObjectPointerType>::Type>
-from_python<mx::ObjCObjectPointerType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnforceTCBAttrSpelling>::Type>
-from_python<mx::EnforceTCBAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReleaseCapabilityAttr>::Type>
-from_python<mx::ReleaseCapabilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::IntegerAttr>::Type>
-from_python<mx::ir::core::IntegerAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnforceTCBLeafAttrSpelling>::Type>
-from_python<mx::EnforceTCBLeafAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumExtensibilityAttrKind>::Type>
-from_python<mx::EnumExtensibilityAttrKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumExtensibilityAttrSpelling>::Type>
-from_python<mx::EnumExtensibilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConceptSpecializationExpr>::Type>
-from_python<mx::ConceptSpecializationExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ChooseExpr>::Type>
-from_python<mx::ChooseExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ElaboratedType>::Type>
-from_python<mx::ir::hl::ElaboratedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ErrorAttrSpelling>::Type>
-from_python<mx::ErrorAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMetaDirective>::Type>
-from_python<mx::OMPMetaDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMaskedDirective>::Type>
-from_python<mx::OMPMaskedDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AtomicExpr>::Type>
-from_python<mx::AtomicExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIsaExpr>::Type>
-from_python<mx::ObjCIsaExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludePathLocation>::Type>
-from_python<mx::IncludePathLocation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCEncodeExpr>::Type>
-from_python<mx::ObjCEncodeExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AddrSpaceCastOp>::Type>
-from_python<mx::ir::llvm::AddrSpaceCastOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CallOp>::Type>
-from_python<mx::ir::hl::CallOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OwnerAttr>::Type>
-from_python<mx::OwnerAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExcludeFromExplicitInstantiationAttrSpelling>::Type>
-from_python<mx::ExcludeFromExplicitInstantiationAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLIntelReqdSubGroupSizeAttr>::Type>
-from_python<mx::OpenCLIntelReqdSubGroupSizeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CStyleCastOp>::Type>
-from_python<mx::ir::hl::CStyleCastOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprConstantExprKind>::Type>
-from_python<mx::ExprConstantExprKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LabelType>::Type>
-from_python<mx::ir::hl::LabelType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprLValueClassification>::Type>
-from_python<mx::ExprLValueClassification>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CPUSpecificAttr>::Type>
-from_python<mx::CPUSpecificAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::FloatAttr>::Type>
-from_python<mx::ir::core::FloatAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprNullPointerConstantKind>::Type>
-from_python<mx::ExprNullPointerConstantKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFReturnsNotRetainedAttr>::Type>
-from_python<mx::CFReturnsNotRetainedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprNullPointerConstantValueDependence>::Type>
-from_python<mx::ExprNullPointerConstantValueDependence>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangTextSectionAttr>::Type>
-from_python<mx::PragmaClangTextSectionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentSizedArrayType>::Type>
-from_python<mx::DependentSizedArrayType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangRelroSectionAttr>::Type>
-from_python<mx::PragmaClangRelroSectionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFTypeTagAttr>::Type>
-from_python<mx::BTFTypeTagAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmStreamingAttr>::Type>
-from_python<mx::ArmStreamingAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprSideEffectsKind>::Type>
-from_python<mx::ExprSideEffectsKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SelectAnyAttr>::Type>
-from_python<mx::SelectAnyAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoUwtableAttr>::Type>
-from_python<mx::NoUwtableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprisModifiableLvalueResult>::Type>
-from_python<mx::ExprisModifiableLvalueResult>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ScopedLockableAttr>::Type>
-from_python<mx::ScopedLockableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoThrowAttr>::Type>
-from_python<mx::NoThrowAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetSimdDirective>::Type>
-from_python<mx::OMPTargetSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetParallelForSimdDirective>::Type>
-from_python<mx::OMPTargetParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ExternalSourceSymbolAttrSpelling>::Type>
-from_python<mx::ExternalSourceSymbolAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AddressOfOp>::Type>
-from_python<mx::ir::llvm::AddressOfOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FallThroughAttrSpelling>::Type>
-from_python<mx::FallThroughAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::VoidAttr>::Type>
-from_python<mx::ir::core::VoidAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeducedType>::Type>
-from_python<mx::DeducedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CaseOp>::Type>
-from_python<mx::ir::hl::CaseOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FastCallAttrSpelling>::Type>
-from_python<mx::FastCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ComplexType>::Type>
-from_python<mx::ComplexType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ClassTemplateDecl>::Type>
-from_python<mx::ClassTemplateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FinalAttrSpelling>::Type>
-from_python<mx::FinalAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AndOp>::Type>
-from_python<mx::ir::llvm::AndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::ScopeRetOp>::Type>
-from_python<mx::ir::ll::ScopeRetOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLSV_GroupIndexAttr>::Type>
-from_python<mx::HLSLSV_GroupIndexAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDefaultInitExpr>::Type>
-from_python<mx::CXXDefaultInitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FlagEnumAttrSpelling>::Type>
-from_python<mx::FlagEnumAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HIPManagedAttr>::Type>
-from_python<mx::HIPManagedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXBoolLiteralExpr>::Type>
-from_python<mx::CXXBoolLiteralExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FlattenAttrSpelling>::Type>
-from_python<mx::FlattenAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::StoreOp>::Type>
-from_python<mx::ir::ll::StoreOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::LValueType>::Type>
-from_python<mx::ir::hl::LValueType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FormatArgAttrSpelling>::Type>
-from_python<mx::FormatArgAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AllocaOp>::Type>
-from_python<mx::ir::llvm::AllocaOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FormatAttrSpelling>::Type>
-from_python<mx::FormatAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionDeclTemplatedKind>::Type>
-from_python<mx::FunctionDeclTemplatedKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCCompatibleAliasDecl>::Type>
-from_python<mx::ObjCCompatibleAliasDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::SourceLanguageAttr>::Type>
-from_python<mx::ir::core::SourceLanguageAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPIteratorExpr>::Type>
-from_python<mx::OMPIteratorExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionReturnThunksAttrKind>::Type>
-from_python<mx::FunctionReturnThunksAttrKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPArraySectionExpr>::Type>
-from_python<mx::OMPArraySectionExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionReturnThunksAttrSpelling>::Type>
-from_python<mx::FunctionReturnThunksAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::RValueType>::Type>
-from_python<mx::ir::hl::RValueType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionTypeAArch64SMETypeAttributes>::Type>
-from_python<mx::FunctionTypeAArch64SMETypeAttributes>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareReductionDecl>::Type>
-from_python<mx::OMPDeclareReductionDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::VarTemplateSpecializationDecl>::Type>
-from_python<mx::VarTemplateSpecializationDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::GlobalLinkageKindAttr>::Type>
-from_python<mx::ir::core::GlobalLinkageKindAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionTypeArmStateValue>::Type>
-from_python<mx::FunctionTypeArmStateValue>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IndexStatus>::Type>
-from_python<mx::IndexStatus>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReinitializesAttr>::Type>
-from_python<mx::ReinitializesAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GNUInlineAttrSpelling>::Type>
-from_python<mx::GNUInlineAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReadOnlyPlacementAttr>::Type>
-from_python<mx::ReadOnlyPlacementAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GuardedVarAttrSpelling>::Type>
-from_python<mx::GuardedVarAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::VoidType>::Type>
-from_python<mx::ir::hl::VoidType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HIPManagedAttrSpelling>::Type>
-from_python<mx::HIPManagedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXThisExpr>::Type>
-from_python<mx::CXXThisExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLParamModifierAttrSpelling>::Type>
-from_python<mx::HLSLParamModifierAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MemberPointerType>::Type>
-from_python<mx::MemberPointerType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXScalarValueInitExpr>::Type>
-from_python<mx::CXXScalarValueInitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLShaderAttrShaderType>::Type>
-from_python<mx::HLSLShaderAttrShaderType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OverrideAttr>::Type>
-from_python<mx::OverrideAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentSizedMatrixType>::Type>
-from_python<mx::DependentSizedMatrixType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HotAttrSpelling>::Type>
-from_python<mx::HotAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLKernelAttr>::Type>
-from_python<mx::OpenCLKernelAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CPUDispatchAttr>::Type>
-from_python<mx::CPUDispatchAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IBActionAttrSpelling>::Type>
-from_python<mx::IBActionAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFReturnsRetainedAttr>::Type>
-from_python<mx::CFReturnsRetainedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstantArrayType>::Type>
-from_python<mx::ConstantArrayType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DecayedType>::Type>
-from_python<mx::DecayedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::SubscriptOp>::Type>
-from_python<mx::ir::ll::SubscriptOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::BoolType>::Type>
-from_python<mx::ir::hl::BoolType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ChooseExprOp>::Type>
-from_python<mx::ir::hl::ChooseExprOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::FunctionType>::Type>
-from_python<mx::ir::core::FunctionType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmStreamingCompatibleAttr>::Type>
-from_python<mx::ArmStreamingCompatibleAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SectionAttr>::Type>
-from_python<mx::SectionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangRodataSectionAttr>::Type>
-from_python<mx::PragmaClangRodataSectionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmPreservesAttr>::Type>
-from_python<mx::ArmPreservesAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLSpecialClassAttr>::Type>
-from_python<mx::SYCLSpecialClassAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangDataSectionAttr>::Type>
-from_python<mx::PragmaClangDataSectionAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoUniqueAddressAttr>::Type>
-from_python<mx::NoUniqueAddressAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoThreadSafetyAnalysisAttr>::Type>
-from_python<mx::NoThreadSafetyAnalysisAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeducedTemplateSpecializationType>::Type>
-from_python<mx::DeducedTemplateSpecializationType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DecltypeType>::Type>
-from_python<mx::DecltypeType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AtomicCmpXchgOp>::Type>
-from_python<mx::ir::llvm::AtomicCmpXchgOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IBOutletAttrSpelling>::Type>
-from_python<mx::IBOutletAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::CharType>::Type>
-from_python<mx::ir::hl::CharType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedDeclId>::Type>
-from_python<PackedDeclId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IBOutletCollectionAttrSpelling>::Type>
-from_python<mx::IBOutletCollectionAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IFuncAttrSpelling>::Type>
-from_python<mx::IFuncAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitCastExprOnStack>::Type>
-from_python<mx::ImplicitCastExprOnStack>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InitPriorityAttrSpelling>::Type>
-from_python<mx::InitPriorityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLSV_DispatchThreadIDAttr>::Type>
-from_python<mx::HLSLSV_DispatchThreadIDAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::GuardedVarAttr>::Type>
-from_python<mx::GuardedVarAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IntelOclBiccAttrSpelling>::Type>
-from_python<mx::IntelOclBiccAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ShortType>::Type>
-from_python<mx::ir::hl::ShortType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::SelectOp>::Type>
-from_python<mx::ir::core::SelectOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InternalLinkageAttrSpelling>::Type>
-from_python<mx::InternalLinkageAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitConceptSpecializationDecl>::Type>
-from_python<mx::ImplicitConceptSpecializationDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMasterDirective>::Type>
-from_python<mx::OMPMasterDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::ll::UninitializedVarOp>::Type>
-from_python<mx::ir::ll::UninitializedVarOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LTOVisibilityPublicAttrSpelling>::Type>
-from_python<mx::LTOVisibilityPublicAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPLoopBasedDirective>::Type>
-from_python<mx::OMPLoopBasedDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::IntType>::Type>
-from_python<mx::ir::hl::IntType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LeafAttrSpelling>::Type>
-from_python<mx::LeafAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::ClassDeclOp>::Type>
-from_python<mx::ir::hl::ClassDeclOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LifetimeBoundAttrSpelling>::Type>
-from_python<mx::LifetimeBoundAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::Operation>::Type>
-from_python<mx::ir::core::Operation>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LikelyAttrSpelling>::Type>
-from_python<mx::LikelyAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIndirectCopyRestoreExpr>::Type>
-from_python<mx::ObjCIndirectCopyRestoreExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDictionaryLiteral>::Type>
-from_python<mx::ObjCDictionaryLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LoaderUninitializedAttrSpelling>::Type>
-from_python<mx::LoaderUninitializedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LoopHintAttrLoopHintState>::Type>
-from_python<mx::LoopHintAttrLoopHintState>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LoopHintAttrOptionType>::Type>
-from_python<mx::LoopHintAttrOptionType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::LoopHintAttrSpelling>::Type>
-from_python<mx::LoopHintAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RegCallAttr>::Type>
-from_python<mx::RegCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::BitcastOp>::Type>
-from_python<mx::ir::llvm::BitcastOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RandomizeLayoutAttr>::Type>
-from_python<mx::RandomizeLayoutAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::hl::Attribute>::Type>
-from_python<mx::ir::hl::Attribute>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::AtomicRMWOp>::Type>
-from_python<mx::ir::llvm::AtomicRMWOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetParallelGenericLoopDirective>::Type>
-from_python<mx::OMPTargetParallelGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::BinLAndOp>::Type>
-from_python<mx::ir::core::BinLAndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetParallelForDirective>::Type>
-from_python<mx::OMPTargetParallelForDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AdjustedType>::Type>
-from_python<mx::AdjustedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSABIAttrSpelling>::Type>
-from_python<mx::MSABIAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MatrixType>::Type>
-from_python<mx::MatrixType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeWithKeyword>::Type>
-from_python<mx::TypeWithKeyword>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::M68kRTDAttrSpelling>::Type>
-from_python<mx::M68kRTDAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstantMatrixType>::Type>
-from_python<mx::ConstantMatrixType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MIGServerRoutineAttrSpelling>::Type>
-from_python<mx::MIGServerRoutineAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFUnknownTransferAttr>::Type>
-from_python<mx::CFUnknownTransferAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OptimizeNoneAttr>::Type>
-from_python<mx::OptimizeNoneAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AutoType>::Type>
-from_python<mx::AutoType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AsTypeExpr>::Type>
-from_python<mx::AsTypeExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSInheritanceAttrSpelling>::Type>
-from_python<mx::MSInheritanceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSP430InterruptAttrSpelling>::Type>
-from_python<mx::MSP430InterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSStructAttrSpelling>::Type>
-from_python<mx::MSStructAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MayAliasAttrSpelling>::Type>
-from_python<mx::MayAliasAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MaybeUndefAttrSpelling>::Type>
-from_python<mx::MaybeUndefAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<ProxyTokenTreeVisitor>::Type>
-from_python<ProxyTokenTreeVisitor>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenTreeNodeKind>::Type>
-from_python<mx::TokenTreeNodeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MicroMipsAttrSpelling>::Type>
-from_python<mx::MicroMipsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MinSizeAttrSpelling>::Type>
-from_python<mx::MinSizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MinVectorWidthAttrSpelling>::Type>
-from_python<mx::MinVectorWidthAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Mips16AttrSpelling>::Type>
-from_python<mx::Mips16AttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsInterruptAttrInterruptType>::Type>
-from_python<mx::MipsInterruptAttrInterruptType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsInterruptAttrSpelling>::Type>
-from_python<mx::MipsInterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VaStartOp>::Type>
-from_python<mx::ir::llvm::VaStartOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingDecl>::Type>
-from_python<mx::UsingDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::OpaqueAttr>::Type>
-from_python<mx::ir::builtin::OpaqueAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsLongCallAttrSpelling>::Type>
-from_python<mx::MipsLongCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FRemOp>::Type>
-from_python<mx::ir::llvm::FRemOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FPTruncOp>::Type>
-from_python<mx::ir::llvm::FPTruncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VarAnnotationOp>::Type>
-from_python<mx::ir::llvm::VarAnnotationOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsShortCallAttrSpelling>::Type>
-from_python<mx::MipsShortCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceFAddOp>::Type>
-from_python<mx::ir::llvm::VPReduceFAddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedFileId>::Type>
-from_python<PackedFileId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ModeAttrSpelling>::Type>
-from_python<mx::ModeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MustTailAttrSpelling>::Type>
-from_python<mx::MustTailAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::SparseElementsAttr>::Type>
-from_python<mx::ir::builtin::SparseElementsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSConsumedAttrSpelling>::Type>
-from_python<mx::NSConsumedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSConsumesSelfAttrSpelling>::Type>
-from_python<mx::NSConsumesSelfAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsAutoreleasedAttrSpelling>::Type>
-from_python<mx::NSReturnsAutoreleasedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MaskedCompressStoreOp>::Type>
-from_python<mx::ir::llvm::MaskedCompressStoreOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsNotRetainedAttrSpelling>::Type>
-from_python<mx::NSReturnsNotRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FSubOp>::Type>
-from_python<mx::ir::llvm::FSubOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::StridedLayoutAttr>::Type>
-from_python<mx::ir::builtin::StridedLayoutAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsRetainedAttrSpelling>::Type>
-from_python<mx::NSReturnsRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NVPTXKernelAttrSpelling>::Type>
-from_python<mx::NVPTXKernelAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NakedAttrSpelling>::Type>
-from_python<mx::NakedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NamedDeclExplicitVisibilityKind>::Type>
-from_python<mx::NamedDeclExplicitVisibilityKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoBuiltinAttrSpelling>::Type>
-from_python<mx::NoBuiltinAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::AttrKind>>::Type>
-from_python<std::span<const mx::AttrKind>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoCommonAttrSpelling>::Type>
-from_python<mx::NoCommonAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MaskedExpandLoadOp>::Type>
-from_python<mx::ir::llvm::MaskedExpandLoadOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DesignatedInitExpr>::Type>
-from_python<mx::DesignatedInitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceFMaxOp>::Type>
-from_python<mx::ir::llvm::VPReduceFMaxOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDebugAttrSpelling>::Type>
-from_python<mx::NoDebugAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDerefAttrSpelling>::Type>
-from_python<mx::NoDerefAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::StringAttr>::Type>
-from_python<mx::ir::builtin::StringAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDestroyAttrSpelling>::Type>
-from_python<mx::NoDestroyAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDuplicateAttrSpelling>::Type>
-from_python<mx::NoDuplicateAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IfStmt>::Type>
-from_python<mx::IfStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoEscapeAttrSpelling>::Type>
-from_python<mx::NoEscapeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IfDefinedMacroDirective>::Type>
-from_python<mx::IfDefinedMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInlineAttrSpelling>::Type>
-from_python<mx::NoInlineAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FenceOp>::Type>
-from_python<mx::ir::llvm::FenceOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInstrumentFunctionAttrSpelling>::Type>
-from_python<mx::NoInstrumentFunctionAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXForRangeStmt>::Type>
-from_python<mx::CXXForRangeStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMergeAttrSpelling>::Type>
-from_python<mx::NoMergeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMicroMipsAttrSpelling>::Type>
-from_python<mx::NoMicroMipsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMips16AttrSpelling>::Type>
-from_python<mx::NoMips16AttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MaskedGatherOp>::Type>
-from_python<mx::ir::llvm::MaskedGatherOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoProfileFunctionAttrSpelling>::Type>
-from_python<mx::NoProfileFunctionAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoRandomizeLayoutAttrSpelling>::Type>
-from_python<mx::NoRandomizeLayoutAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceFMinOp>::Type>
-from_python<mx::ir::llvm::VPReduceFMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoReturnAttrSpelling>::Type>
-from_python<mx::NoReturnAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSanitizeAttrSpelling>::Type>
-from_python<mx::NoSanitizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSpeculativeLoadHardeningAttrSpelling>::Type>
-from_python<mx::NoSpeculativeLoadHardeningAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::SymbolRefAttr>::Type>
-from_python<mx::ir::builtin::SymbolRefAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSplitStackAttrSpelling>::Type>
-from_python<mx::NoSplitStackAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoawaitExpr>::Type>
-from_python<mx::CoawaitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoStackProtectorAttrSpelling>::Type>
-from_python<mx::NoStackProtectorAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoThreadSafetyAnalysisAttrSpelling>::Type>
-from_python<mx::NoThreadSafetyAnalysisAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoThrowAttrSpelling>::Type>
-from_python<mx::NoThrowAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoUniqueAddressAttrSpelling>::Type>
-from_python<mx::NoUniqueAddressAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::TypeAttr>::Type>
-from_python<mx::ir::builtin::TypeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NoUwtableAttrSpelling>::Type>
-from_python<mx::NoUwtableAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::MSDependentExistsStmt>::Type>
-from_python<mx::MSDependentExistsStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NonNullAttrSpelling>::Type>
-from_python<mx::NonNullAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::core::Type>::Type>
-from_python<mx::ir::core::Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NotTailCalledAttrSpelling>::Type>
-from_python<mx::NotTailCalledAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::MaskedScatterOp>::Type>
-from_python<mx::ir::llvm::MaskedScatterOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceFMulOp>::Type>
-from_python<mx::ir::llvm::VPReduceFMulOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPAllocateDeclAttrAllocatorTypeTy>::Type>
-from_python<mx::OMPAllocateDeclAttrAllocatorTypeTy>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareSimdDeclAttrBranchStateTy>::Type>
-from_python<mx::OMPDeclareSimdDeclAttrBranchStateTy>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CleanupAttr>::Type>
-from_python<mx::CleanupAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareTargetDeclAttrDevTypeTy>::Type>
-from_python<mx::OMPDeclareTargetDeclAttrDevTypeTy>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::Ptr32Attr>::Type>
-from_python<mx::Ptr32Attr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::UnitAttr>::Type>
-from_python<mx::ir::builtin::UnitAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FreezeOp>::Type>
-from_python<mx::ir::llvm::FreezeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareTargetDeclAttrMapTypeTy>::Type>
-from_python<mx::OMPDeclareTargetDeclAttrMapTypeTy>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSConsumedAttrSpelling>::Type>
-from_python<mx::OSConsumedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftBridgedTypedefAttr>::Type>
-from_python<mx::SwiftBridgedTypedefAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::BoolAttr>::Type>
-from_python<mx::ir::builtin::BoolAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSConsumesThisAttrSpelling>::Type>
-from_python<mx::OSConsumesThisAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InitPriorityAttr>::Type>
-from_python<mx::InitPriorityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsNotRetainedAttrSpelling>::Type>
-from_python<mx::OSReturnsNotRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedAttrSpelling>::Type>
-from_python<mx::OSReturnsRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceMulOp>::Type>
-from_python<mx::ir::llvm::VPReduceMulOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorExtractOp>::Type>
-from_python<mx::ir::llvm::VectorExtractOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedOnNonZeroAttrSpelling>::Type>
-from_python<mx::OSReturnsRetainedOnNonZeroAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedOnZeroAttrSpelling>::Type>
-from_python<mx::OSReturnsRetainedOnZeroAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IfMacroDirective>::Type>
-from_python<mx::IfMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBoxableAttrSpelling>::Type>
-from_python<mx::ObjCBoxableAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquireCapabilityAttr>::Type>
-from_python<mx::AcquireCapabilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeAttrSpelling>::Type>
-from_python<mx::ObjCBridgeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::GetElementPtrOp>::Type>
-from_python<mx::ir::llvm::GetElementPtrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeMutableAttrSpelling>::Type>
-from_python<mx::ObjCBridgeMutableAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::FlatSymbolRefAttr>::Type>
-from_python<mx::ir::builtin::FlatSymbolRefAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeRelatedAttrSpelling>::Type>
-from_python<mx::ObjCBridgeRelatedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCClassStubAttrSpelling>::Type>
-from_python<mx::ObjCClassStubAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDesignatedInitializerAttrSpelling>::Type>
-from_python<mx::ObjCDesignatedInitializerAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StringLiteral>::Type>
-from_python<mx::StringLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDirectAttrSpelling>::Type>
-from_python<mx::ObjCDirectAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConvergentAttr>::Type>
-from_python<mx::ConvergentAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::DenseIntElementsAttr>::Type>
-from_python<mx::ir::builtin::DenseIntElementsAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDirectMembersAttrSpelling>::Type>
-from_python<mx::ObjCDirectMembersAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExceptionAttrSpelling>::Type>
-from_python<mx::ObjCExceptionAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExplicitProtocolImplAttrSpelling>::Type>
-from_python<mx::ObjCExplicitProtocolImplAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceOrOp>::Type>
-from_python<mx::ir::llvm::VPReduceOrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExternallyRetainedAttrSpelling>::Type>
-from_python<mx::ObjCExternallyRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenCategory>::Type>
-from_python<mx::TokenCategory>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclStmt>::Type>
-from_python<mx::DeclStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorInsertOp>::Type>
-from_python<mx::ir::llvm::VectorInsertOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCGCAttrSpelling>::Type>
-from_python<mx::ObjCGCAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::GlobalCtorsOp>::Type>
-from_python<mx::ir::llvm::GlobalCtorsOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIndependentClassAttrSpelling>::Type>
-from_python<mx::ObjCIndependentClassAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::DataLayoutSpecAttr>::Type>
-from_python<mx::ir::builtin::DataLayoutSpecAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Type>::Type>
-from_python<mx::ir::builtin::Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIvarDeclAccessControl>::Type>
-from_python<mx::ObjCIvarDeclAccessControl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedMemberExpr>::Type>
-from_python<mx::UnresolvedMemberExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMessageExprReceiverKind>::Type>
-from_python<mx::ObjCMessageExprReceiverKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPSIToFPOp>::Type>
-from_python<mx::ir::llvm::VPSIToFPOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::XRayInstrumentAttr>::Type>
-from_python<mx::XRayInstrumentAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodFamilyAttrFamilyKind>::Type>
-from_python<mx::ObjCMethodFamilyAttrFamilyKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedRecordAttr>::Type>
-from_python<mx::CapturedRecordAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLPrivateAddressSpaceAttr>::Type>
-from_python<mx::OpenCLPrivateAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::GlobalDtorsOp>::Type>
-from_python<mx::ir::llvm::GlobalDtorsOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPSRemOp>::Type>
-from_python<mx::ir::llvm::VPSRemOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftBridgeAttr>::Type>
-from_python<mx::SwiftBridgeAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodFamilyAttrSpelling>::Type>
-from_python<mx::ObjCMethodFamilyAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNSObjectAttrSpelling>::Type>
-from_python<mx::ObjCNSObjectAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<FileLocationCache>::Type>
-from_python<FileLocationCache>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceSMaxOp>::Type>
-from_python<mx::ir::llvm::VPReduceSMaxOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::InheritableParamAttr>::Type>
-from_python<mx::InheritableParamAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::GlobalOp>::Type>
-from_python<mx::ir::llvm::GlobalOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNonLazyClassAttrSpelling>::Type>
-from_python<mx::ObjCNonLazyClassAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNonRuntimeProtocolAttrSpelling>::Type>
-from_python<mx::ObjCNonRuntimeProtocolAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceAddOp>::Type>
-from_python<mx::ir::llvm::VectorReduceAddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::ShapedType>::Type>
-from_python<mx::ir::builtin::ShapedType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCOwnershipAttrSpelling>::Type>
-from_python<mx::ObjCOwnershipAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroutineSuspendExpr>::Type>
-from_python<mx::CoroutineSuspendExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPreciseLifetimeAttrSpelling>::Type>
-from_python<mx::ObjCPreciseLifetimeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::ICmpOp>::Type>
-from_python<mx::ir::llvm::ICmpOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyDeclPropertyControl>::Type>
-from_python<mx::ObjCPropertyDeclPropertyControl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyDeclSetterKind>::Type>
-from_python<mx::ObjCPropertyDeclSetterKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AVRSignalAttr>::Type>
-from_python<mx::AVRSignalAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclRefExpr>::Type>
-from_python<mx::DeclRefExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyImplDeclKind>::Type>
-from_python<mx::ObjCPropertyImplDeclKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::vector<std::variant<UserToken, mx::Token>>>::Type>
-from_python<std::vector<std::variant<UserToken, mx::Token>>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludeLikeMacroDirective>::Type>
-from_python<mx::IncludeLikeMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRequiresPropertyDefsAttrSpelling>::Type>
-from_python<mx::ObjCRequiresPropertyDefsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceSMinOp>::Type>
-from_python<mx::ir::llvm::VPReduceSMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableSetOnReadAttr>::Type>
-from_python<mx::ConsumableSetOnReadAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDirective>::Type>
-from_python<mx::OMPTargetTeamsDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetExitDataDirective>::Type>
-from_python<mx::OMPTargetExitDataDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::FloatType>::Type>
-from_python<mx::ir::builtin::FloatType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRequiresSuperAttrSpelling>::Type>
-from_python<mx::ObjCRequiresSuperAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceAndOp>::Type>
-from_python<mx::ir::llvm::VectorReduceAndOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCReturnsInnerPointerAttrSpelling>::Type>
-from_python<mx::ObjCReturnsInnerPointerAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRootClassAttrSpelling>::Type>
-from_python<mx::ObjCRootClassAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRuntimeNameAttrSpelling>::Type>
-from_python<mx::ObjCRuntimeNameAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLBufferDecl>::Type>
-from_python<mx::HLSLBufferDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRuntimeVisibleAttrSpelling>::Type>
-from_python<mx::ObjCRuntimeVisibleAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSubclassingRestrictedAttrSpelling>::Type>
-from_python<mx::ObjCSubclassingRestrictedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPSectionDirective>::Type>
-from_python<mx::OMPSectionDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLAccessAttrSpelling>::Type>
-from_python<mx::OpenCLAccessAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPScanDirective>::Type>
-from_python<mx::OMPScanDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLConstantAddressSpaceAttrSpelling>::Type>
-from_python<mx::OpenCLConstantAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGenericAddressSpaceAttrSpelling>::Type>
-from_python<mx::OpenCLGenericAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CapabilityAttr>::Type>
-from_python<mx::CapabilityAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::ComplexType>::Type>
-from_python<mx::ir::builtin::ComplexType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalAddressSpaceAttrSpelling>::Type>
-from_python<mx::OpenCLGlobalAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLLocalAddressSpaceAttr>::Type>
-from_python<mx::OpenCLLocalAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::X86ForceAlignArgPointerAttr>::Type>
-from_python<mx::X86ForceAlignArgPointerAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling>::Type>
-from_python<mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceUMaxOp>::Type>
-from_python<mx::ir::llvm::VPReduceUMaxOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalHostAddressSpaceAttrSpelling>::Type>
-from_python<mx::OpenCLGlobalHostAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceFAddOp>::Type>
-from_python<mx::ir::llvm::VectorReduceFAddOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLKernelAttrSpelling>::Type>
-from_python<mx::OpenCLKernelAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAttrAttr>::Type>
-from_python<mx::SwiftAttrAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float8E5M2Type>::Type>
-from_python<mx::ir::builtin::Float8E5M2Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLLocalAddressSpaceAttrSpelling>::Type>
-from_python<mx::OpenCLLocalAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLPrivateAddressSpaceAttrSpelling>::Type>
-from_python<mx::OpenCLPrivateAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CarriesDependencyAttr>::Type>
-from_python<mx::CarriesDependencyAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OptimizeNoneAttrSpelling>::Type>
-from_python<mx::OptimizeNoneAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadableAttrSpelling>::Type>
-from_python<mx::OverloadableAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OwnershipAttrOwnershipKind>::Type>
-from_python<mx::OwnershipAttrOwnershipKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDistributeDirective>::Type>
-from_python<mx::OMPTeamsDistributeDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskLoopDirective>::Type>
-from_python<mx::OMPTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::InlineAsmOp>::Type>
-from_python<mx::ir::llvm::InlineAsmOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OwnershipAttrSpelling>::Type>
-from_python<mx::OwnershipAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float8E4M3FNType>::Type>
-from_python<mx::ir::builtin::Float8E4M3FNType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PackedAttrSpelling>::Type>
-from_python<mx::PackedAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXOperatorCallExpr>::Type>
-from_python<mx::CXXOperatorCallExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAKernelCallExpr>::Type>
-from_python<mx::CUDAKernelCallExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AVRInterruptAttr>::Type>
-from_python<mx::AVRInterruptAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceFMaxOp>::Type>
-from_python<mx::ir::llvm::VectorReduceFMaxOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUWavesPerEUAttr>::Type>
-from_python<mx::AMDGPUWavesPerEUAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPRequiresDecl>::Type>
-from_python<mx::OMPRequiresDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNoexceptExpr>::Type>
-from_python<mx::CXXNoexceptExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TranslationUnitDecl>::Type>
-from_python<mx::TranslationUnitDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceUMinOp>::Type>
-from_python<mx::ir::llvm::VPReduceUMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXInheritedCtorInitExpr>::Type>
-from_python<mx::CXXInheritedCtorInitExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParamTypestateAttrConsumedState>::Type>
-from_python<mx::ParamTypestateAttrConsumedState>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ParamTypestateAttrSpelling>::Type>
-from_python<mx::ParamTypestateAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXCatchStmt>::Type>
-from_python<mx::CXXCatchStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float8E5M2FNUZType>::Type>
-from_python<mx::ir::builtin::Float8E5M2FNUZType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PascalAttrSpelling>::Type>
-from_python<mx::PascalAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PassObjectSizeAttrSpelling>::Type>
-from_python<mx::PassObjectSizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAutoCastAttr>::Type>
-from_python<mx::ConsumableAutoCastAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceOrOp>::Type>
-from_python<mx::ir::llvm::VectorReduceOrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PatchableFunctionEntryAttrSpelling>::Type>
-from_python<mx::PatchableFunctionEntryAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstructorAttr>::Type>
-from_python<mx::ConstructorAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCStringLiteral>::Type>
-from_python<mx::ObjCStringLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ImportMacroDirective>::Type>
-from_python<mx::ImportMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PcsAttrPCSType>::Type>
-from_python<mx::PcsAttrPCSType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PcsAttrSpelling>::Type>
-from_python<mx::PcsAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::InsertElementOp>::Type>
-from_python<mx::ir::llvm::InsertElementOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PreferredNameAttrSpelling>::Type>
-from_python<mx::PreferredNameAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AddrLabelExpr>::Type>
-from_python<mx::AddrLabelExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float8E4M3FNUZType>::Type>
-from_python<mx::ir::builtin::Float8E4M3FNUZType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceFMaximumOp>::Type>
-from_python<mx::ir::llvm::VectorReduceFMaximumOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PreferredTypeAttrSpelling>::Type>
-from_python<mx::PreferredTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PreserveAllAttrSpelling>::Type>
-from_python<mx::PreserveAllAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPReduceXorOp>::Type>
-from_python<mx::ir::llvm::VPReduceXorOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PreserveMostAttrSpelling>::Type>
-from_python<mx::PreserveMostAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float8E4M3B11FNUZType>::Type>
-from_python<mx::ir::builtin::Float8E4M3B11FNUZType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PtGuardedVarAttrSpelling>::Type>
-from_python<mx::PtGuardedVarAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::PureAttrSpelling>::Type>
-from_python<mx::PureAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WorkGroupSizeHintAttr>::Type>
-from_python<mx::WorkGroupSizeHintAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedLookupExpr>::Type>
-from_python<mx::UnresolvedLookupExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalHostAddressSpaceAttr>::Type>
-from_python<mx::OpenCLGlobalHostAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyImportModuleAttr>::Type>
-from_python<mx::WebAssemblyImportModuleAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedTypeDestructionKind>::Type>
-from_python<mx::QualifiedTypeDestructionKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalAddressSpaceAttr>::Type>
-from_python<mx::OpenCLGlobalAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedTypeNonConstantStorageReason>::Type>
-from_python<mx::QualifiedTypeNonConstantStorageReason>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CallbackAttr>::Type>
-from_python<mx::CallbackAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXX11NoReturnAttr>::Type>
-from_python<mx::CXX11NoReturnAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedTypePrimitiveCopyKind>::Type>
-from_python<mx::QualifiedTypePrimitiveCopyKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadExpr>::Type>
-from_python<mx::OverloadExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncNameAttr>::Type>
-from_python<mx::SwiftAsyncNameAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncCallAttr>::Type>
-from_python<mx::SwiftAsyncCallAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::InsertValueOp>::Type>
-from_python<mx::ir::llvm::InsertValueOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::BFloat16Type>::Type>
-from_python<mx::ir::builtin::BFloat16Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedTypePrimitiveDefaultInitializeKind>::Type>
-from_python<mx::QualifiedTypePrimitiveDefaultInitializeKind>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CFConsumedAttr>::Type>
-from_python<mx::CFConsumedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceFMinOp>::Type>
-from_python<mx::ir::llvm::VectorReduceFMinOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RISCVInterruptAttrInterruptType>::Type>
-from_python<mx::RISCVInterruptAttrInterruptType>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UseHandleAttr>::Type>
-from_python<mx::UseHandleAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetParallelDirective>::Type>
-from_python<mx::OMPTargetParallelDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetEnterDataDirective>::Type>
-from_python<mx::OMPTargetEnterDataDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RISCVInterruptAttrSpelling>::Type>
-from_python<mx::RISCVInterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::NullStmt>::Type>
-from_python<mx::NullStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IndirectGotoStmt>::Type>
-from_python<mx::IndirectGotoStmt>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPSDivOp>::Type>
-from_python<mx::ir::llvm::VPSDivOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float16Type>::Type>
-from_python<mx::ir::builtin::Float16Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RandomizeLayoutAttrSpelling>::Type>
-from_python<mx::RandomizeLayoutAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<PackedFragmentId>::Type>
-from_python<PackedFragmentId>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReadOnlyPlacementAttrSpelling>::Type>
-from_python<mx::ReadOnlyPlacementAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ARMInterruptAttr>::Type>
-from_python<mx::ARMInterruptAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RegCallAttrSpelling>::Type>
-from_python<mx::RegCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUNumVGPRAttr>::Type>
-from_python<mx::AMDGPUNumVGPRAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReinitializesAttrSpelling>::Type>
-from_python<mx::ReinitializesAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPScopeDirective>::Type>
-from_python<mx::OMPScopeDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReleaseCapabilityAttrSpelling>::Type>
-from_python<mx::ReleaseCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelSectionsDirective>::Type>
-from_python<mx::OMPParallelSectionsDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingEnumDecl>::Type>
-from_python<mx::UsingEnumDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReleaseHandleAttrSpelling>::Type>
-from_python<mx::ReleaseHandleAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UnnamedGlobalConstantDecl>::Type>
-from_python<mx::UnnamedGlobalConstantDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::IntToPtrOp>::Type>
-from_python<mx::ir::llvm::IntToPtrOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceFMinimumOp>::Type>
-from_python<mx::ir::llvm::VectorReduceFMinimumOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RequiresCapabilityAttrSpelling>::Type>
-from_python<mx::RequiresCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::FloatTF32Type>::Type>
-from_python<mx::ir::builtin::FloatTF32Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RestrictAttrSpelling>::Type>
-from_python<mx::RestrictAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAttr>::Type>
-from_python<mx::ConsumableAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstInitAttr>::Type>
-from_python<mx::ConstInitAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RegexQuery>::Type>
-from_python<mx::RegexQuery>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::RetainAttrSpelling>::Type>
-from_python<mx::RetainAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnTypestateAttrConsumedState>::Type>
-from_python<mx::ReturnTypestateAttrConsumedState>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnTypestateAttrSpelling>::Type>
-from_python<mx::ReturnTypestateAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnsNonNullAttrSpelling>::Type>
-from_python<mx::ReturnsNonNullAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float32Type>::Type>
-from_python<mx::ir::builtin::Float32Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludeMacrosMacroDirective>::Type>
-from_python<mx::IncludeMacrosMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludeNextMacroDirective>::Type>
-from_python<mx::IncludeNextMacroDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VPSExtOp>::Type>
-from_python<mx::ir::llvm::VPSExtOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnsTwiceAttrSpelling>::Type>
-from_python<mx::ReturnsTwiceAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLKernelAttrSpelling>::Type>
-from_python<mx::SYCLKernelAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskLoopSimdDirective>::Type>
-from_python<mx::OMPTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::InvokeOp>::Type>
-from_python<mx::ir::llvm::InvokeOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLSpecialClassAttrSpelling>::Type>
-from_python<mx::SYCLSpecialClassAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsGenericLoopDirective>::Type>
-from_python<mx::OMPTargetTeamsGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceMulOp>::Type>
-from_python<mx::ir::llvm::VectorReduceMulOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ScopedLockableAttrSpelling>::Type>
-from_python<mx::ScopedLockableAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::VectorReduceFMulOp>::Type>
-from_python<mx::ir::llvm::VectorReduceFMulOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SectionAttrSpelling>::Type>
-from_python<mx::SectionAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalDeviceAddressSpaceAttr>::Type>
-from_python<mx::OpenCLGlobalDeviceAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float64Type>::Type>
-from_python<mx::ir::builtin::Float64Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SelectAnyAttrSpelling>::Type>
-from_python<mx::SelectAnyAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGenericAddressSpaceAttr>::Type>
-from_python<mx::OpenCLGenericAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float128Type>::Type>
-from_python<mx::ir::builtin::Float128Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SentinelAttrSpelling>::Type>
-from_python<mx::SentinelAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CallableWhenAttr>::Type>
-from_python<mx::CallableWhenAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDASharedAttr>::Type>
-from_python<mx::CUDASharedAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SetTypestateAttrConsumedState>::Type>
-from_python<mx::SetTypestateAttrConsumedState>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXMemberCallExpr>::Type>
-from_python<mx::CXXMemberCallExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::UserDefinedLiteral>::Type>
-from_python<mx::UserDefinedLiteral>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SetTypestateAttrSpelling>::Type>
-from_python<mx::SetTypestateAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPAllocateDecl>::Type>
-from_python<mx::OMPAllocateDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyImportNameAttr>::Type>
-from_python<mx::WebAssemblyImportNameAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::TopLevelStmtDecl>::Type>
-from_python<mx::TopLevelStmtDecl>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Fragment>>::Type>
-from_python<std::optional<mx::Fragment>>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyExportNameAttr>::Type>
-from_python<mx::WebAssemblyExportNameAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::AnnotateAttr>::Type>
-from_python<mx::AnnotateAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::builtin::Float80Type>::Type>
-from_python<mx::ir::builtin::Float80Type>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SpeculativeLoadHardeningAttrSpelling>::Type>
-from_python<mx::SpeculativeLoadHardeningAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncErrorAttr>::Type>
-from_python<mx::SwiftAsyncErrorAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ReleaseHandleAttr>::Type>
-from_python<mx::ReleaseHandleAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNewExpr>::Type>
-from_python<mx::CXXNewExpr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncAttr>::Type>
-from_python<mx::SwiftAsyncAttr>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::ir::llvm::FuncOp>::Type>
-from_python<mx::ir::llvm::FuncOp>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT std::optional<FromPythonReturnType<mx::StdCallAttrSpelling>::Type>
-from_python<mx::StdCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::StmtLikelihood>(mx::StmtLikelihood) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::StmtKind>(mx::StmtKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExtVectorElementExpr>>(gap::generator<mx::ExtVectorElementExpr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SuppressAttrSpelling>(mx::SuppressAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CmpOp>>(std::optional<mx::ir::hl::CmpOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCancellationPointDirective>>(gap::generator<mx::OMPCancellationPointDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncAttrKind>(mx::SwiftAsyncAttrKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroParameterSubstitution>>(gap::generator<mx::MacroParameterSubstitution>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TypeTrait>(mx::TypeTrait) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncAttrSpelling>(mx::SwiftAsyncAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncCallAttrSpelling>(mx::SwiftAsyncCallAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UnaryExprOrTypeTrait>(mx::UnaryExprOrTypeTrait) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncContextAttrSpelling>(mx::SwiftAsyncContextAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UnaryOperatorKind>(mx::UnaryOperatorKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncErrorAttrConventionKind>(mx::SwiftAsyncErrorAttrConventionKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncErrorAttrSpelling>(mx::SwiftAsyncErrorAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CondOp>(mx::ir::hl::CondOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftCallAttrSpelling>(mx::SwiftCallAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareSimdDeclAttr>>(std::optional<mx::OMPDeclareSimdDeclAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArgumentWithTypeTagAttr>>(std::optional<mx::ArgumentWithTypeTagAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CompoundLiteralOp>(mx::ir::hl::CompoundLiteralOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExtVectorElementExpr>>(std::optional<mx::ExtVectorElementExpr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::APValueKind>(mx::APValueKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftContextAttrSpelling>(mx::SwiftContextAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CompoundLiteralOp>>(std::optional<mx::ir::hl::CompoundLiteralOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VectorKind>(mx::VectorKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftErrorAttrConventionKind>(mx::SwiftErrorAttrConventionKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCancellationPointDirective>>(std::optional<mx::OMPCancellationPointDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftErrorResultAttrSpelling>(mx::SwiftErrorResultAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftIndirectResultAttrSpelling>(mx::SwiftIndirectResultAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ExtVectorElementExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ExtVectorElementExpr, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftNewTypeAttrNewtypeKind>(mx::SwiftNewTypeAttrNewtypeKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPCancellationPointDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPCancellationPointDirective, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftNewTypeAttrSpelling>(mx::SwiftNewTypeAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Visibility>(mx::Visibility) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::SysVABIAttrSpelling>(mx::SysVABIAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroParameterSubstitution>>(std::optional<mx::MacroParameterSubstitution>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TLSModelAttrSpelling>(mx::TLSModelAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CondOp>>(std::optional<mx::ir::hl::CondOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TargetAttrSpelling>(mx::TargetAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TargetClonesAttrSpelling>(mx::TargetClonesAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TargetVersionAttrSpelling>(mx::TargetVersionAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VisibilityForcedKinds>(mx::VisibilityForcedKinds) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPForSimdDirective>>(gap::generator<mx::OMPForSimdDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateArgumentKind>(mx::TemplateArgumentKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VisibilityFromDLLStorageClassKinds>(mx::VisibilityFromDLLStorageClassKinds) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TestTypestateAttrConsumedState>(mx::TestTypestateAttrConsumedState) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AttributeSyntax>(mx::AttributeSyntax) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TestTypestateAttrSpelling>(mx::TestTypestateAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Expr>>(std::optional<mx::Expr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArcWeakrefUnavailableAttr>>(gap::generator<mx::ArcWeakrefUnavailableAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::DeclCategory>(mx::DeclCategory) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Expr>(mx::Expr) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCaptureKindAttr>>(gap::generator<mx::OMPCaptureKindAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ValueStmt>(mx::ValueStmt) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CondYieldOp>(mx::ir::hl::CondYieldOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ThisCallAttrSpelling>(mx::ThisCallAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::PseudoKind>(mx::PseudoKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TransparentUnionAttrSpelling>(mx::TransparentUnionAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ValueStmt>>(gap::generator<mx::ValueStmt>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TrivialABIAttrSpelling>(mx::TrivialABIAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TryAcquireCapabilityAttrSpelling>(mx::TryAcquireCapabilityAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CondYieldOp>>(std::optional<mx::ir::hl::CondYieldOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TypeScalarTypeKind>(mx::TypeScalarTypeKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::MacroParameter>(mx::MacroParameter) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TypeKind>(mx::TypeKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::EntityCategory>(mx::EntityCategory) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPForSimdDirective>>(std::optional<mx::OMPForSimdDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TypeTagForDatatypeAttrSpelling>(mx::TypeTagForDatatypeAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroParameter>>(gap::generator<mx::MacroParameter>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TypeVisibilityAttrSpelling>(mx::TypeVisibilityAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArcWeakrefUnavailableAttr>>(std::optional<mx::ArcWeakrefUnavailableAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPForSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPForSimdDirective, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ConstantOp>(mx::ir::hl::ConstantOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCaptureKindAttr>>(std::optional<mx::OMPCaptureKindAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ConstantOp>>(std::optional<mx::ir::hl::ConstantOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ValueStmt>>(std::optional<mx::ValueStmt>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AlignValueAttr>(mx::AlignValueAttr) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ValueStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ValueStmt, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<EntityId>(EntityId) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCancelDirective>>(gap::generator<mx::OMPCancelDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TypeVisibilityAttrVisibilityType>(mx::TypeVisibilityAttrVisibilityType) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExpressionTraitExpr>>(gap::generator<mx::ExpressionTraitExpr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UnaryTransformTypeUTTKind>(mx::UnaryTransformTypeUTTKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Decl>(mx::Decl) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ContinueOp>(mx::ir::hl::ContinueOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UnavailableAttrImplicitReason>(mx::UnavailableAttrImplicitReason) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Decl>>(std::optional<mx::Decl>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<VariantEntity>(VariantEntity) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ContinueOp>>(std::optional<mx::ir::hl::ContinueOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UnavailableAttrSpelling>(mx::UnavailableAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroParameter>>(std::optional<mx::MacroParameter>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UninitializedAttrSpelling>(mx::UninitializedAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Stmt>>(std::optional<mx::Stmt>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CxxBaseSpecifierOp>(mx::ir::hl::CxxBaseSpecifierOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UnlikelyAttrSpelling>(mx::UnlikelyAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnyX86NoCfCheckAttr>>(gap::generator<mx::AnyX86NoCfCheckAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UnsafeBufferUsageAttrSpelling>(mx::UnsafeBufferUsageAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Stmt>(mx::Stmt) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UnusedAttrSpelling>(mx::UnusedAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoEscapeAttr>>(gap::generator<mx::NoEscapeAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UseHandleAttrSpelling>(mx::UseHandleAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UsedAttrSpelling>(mx::UsedAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CxxBaseSpecifierOp>>(std::optional<mx::ir::hl::CxxBaseSpecifierOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UserDefinedLiteralLiteralOperatorKind>(mx::UserDefinedLiteralLiteralOperatorKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCancelDirective>>(std::optional<mx::OMPCancelDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExpressionTraitExpr>>(std::optional<mx::ExpressionTraitExpr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UsingIfExistsAttrSpelling>(mx::UsingIfExistsAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UuidAttrSpelling>(mx::UuidAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<SpecificEntityId<DeclId>>>(std::optional<SpecificEntityId<DeclId>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPCancelDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPCancelDirective, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ExpressionTraitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ExpressionTraitExpr, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Stmt>>(gap::generator<mx::Stmt>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VarDeclDefinitionKind>(mx::VarDeclDefinitionKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CxxStructDeclOp>(mx::ir::hl::CxxStructDeclOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VarDeclInitializationStyle>(mx::VarDeclInitializationStyle) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VarDeclTLSKind>(mx::VarDeclTLSKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Index>(mx::Index) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VecReturnAttrSpelling>(mx::VecReturnAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnyX86NoCfCheckAttr>>(std::optional<mx::AnyX86NoCfCheckAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CxxStructDeclOp>>(std::optional<mx::ir::hl::CxxStructDeclOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoEscapeAttr>>(std::optional<mx::NoEscapeAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VectorCallAttrSpelling>(mx::VectorCallAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPForDirective>>(gap::generator<mx::OMPForDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaMacroDirective>(mx::PragmaMacroDirective) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VisibilityAttrSpelling>(mx::VisibilityAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaMacroDirective>>(gap::generator<mx::PragmaMacroDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::VisibilityAttrVisibilityType>(mx::VisibilityAttrVisibilityType) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::WarnUnusedAttrSpelling>(mx::WarnUnusedAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::WarnUnusedResultAttrSpelling>(mx::WarnUnusedResultAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Expr>>(gap::generator<mx::Expr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::WeakAttrSpelling>(mx::WeakAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DeclRefOp>(mx::ir::hl::DeclRefOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::filesystem::path>(std::filesystem::path) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::WeakImportAttrSpelling>(mx::WeakImportAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Compilation>(mx::Compilation) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::WeakRefAttrSpelling>(mx::WeakRefAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyExportNameAttrSpelling>(mx::WebAssemblyExportNameAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DeclRefOp>>(std::optional<mx::ir::hl::DeclRefOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyImportModuleAttrSpelling>(mx::WebAssemblyImportModuleAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPForDirective>>(std::optional<mx::OMPForDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Fragment>(mx::Fragment) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyImportNameAttrSpelling>(mx::WebAssemblyImportNameAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AnyX86NoCallerSavedRegistersAttr>(mx::AnyX86NoCallerSavedRegistersAttr) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::X86ForceAlignArgPointerAttrSpelling>(mx::X86ForceAlignArgPointerAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnyX86NoCallerSavedRegistersAttr>>(gap::generator<mx::AnyX86NoCallerSavedRegistersAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::NoBuiltinAttr>(mx::NoBuiltinAttr) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Fragment>>(std::optional<mx::Fragment>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::XRayInstrumentAttrSpelling>(mx::XRayInstrumentAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoBuiltinAttr>>(gap::generator<mx::NoBuiltinAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPForDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPForDirective, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::XRayLogArgsAttrSpelling>(mx::XRayLogArgsAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ZeroCallUsedRegsAttrSpelling>(mx::ZeroCallUsedRegsAttrSpelling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<SpecificEntityId<FragmentId>>>(std::optional<SpecificEntityId<FragmentId>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DerefOp>(mx::ir::hl::DerefOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind>(mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DefaultOp>(mx::ir::hl::DefaultOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ASTDumpOutputFormat>(mx::ASTDumpOutputFormat) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AccessSpecifier>(mx::AccessSpecifier) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::RegexQueryMatch>(mx::RegexQueryMatch) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaMacroDirective>>(std::optional<mx::PragmaMacroDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DefaultOp>>(std::optional<mx::ir::hl::DefaultOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::Expr, mx::ir::Operation>>>(gap::generator<std::pair<mx::Expr, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::OMPBarrierDirective>(mx::OMPBarrierDirective) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDirective>(mx::OMPTeamsDirective) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPBarrierDirective>>(gap::generator<mx::OMPBarrierDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AddrSpaceMapMangling>(mx::AddrSpaceMapMangling) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnyX86NoCallerSavedRegistersAttr>>(std::optional<mx::AnyX86NoCallerSavedRegistersAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AlignRequirementKind>(mx::AlignRequirementKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AttributedStmt>(mx::AttributedStmt) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Token>(mx::Token) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoBuiltinAttr>>(std::optional<mx::NoBuiltinAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::CaseStmt>(mx::CaseStmt) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AttributedStmt>>(gap::generator<mx::AttributedStmt>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Token>>(std::optional<mx::Token>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AltivecSrcCompatKind>(mx::AltivecSrcCompatKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DerefOp>>(std::optional<mx::ir::hl::DerefOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ArgumentKind>(mx::ArgumentKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ArraySizeModifier>(mx::ArraySizeModifier) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::TokenKind>(mx::TokenKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::UndefineMacroDirective>(mx::UndefineMacroDirective) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPBarrierDirective>>(std::optional<mx::OMPBarrierDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UndefineMacroDirective>>(gap::generator<mx::UndefineMacroDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ArrayTypeTrait>(mx::ArrayTypeTrait) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DivFOp>(mx::ir::hl::DivFOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AtomicScopeModelKind>(mx::AtomicScopeModelKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DivFAssignOp>(mx::ir::hl::DivFAssignOp) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPBarrierDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPBarrierDirective, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AttributedStmt>>(std::optional<mx::AttributedStmt>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DivFAssignOp>>(std::optional<mx::ir::hl::DivFAssignOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AnyX86InterruptAttr>(mx::AnyX86InterruptAttr) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AutoTypeKeyword>(mx::AutoTypeKeyword) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::AvailabilityResult>(mx::AvailabilityResult) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnyX86InterruptAttr>>(gap::generator<mx::AnyX86InterruptAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ModeAttr>(mx::ModeAttr) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Attr>(mx::Attr) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ModeAttr>>(gap::generator<mx::ModeAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::AttributedStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::AttributedStmt, mx::ir::Operation>>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::BinaryOperatorKind>(mx::BinaryOperatorKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDistributeSimdDirective>(mx::OMPDistributeSimdDirective) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDistributeParallelForDirective>(mx::OMPDistributeParallelForDirective) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDistributeSimdDirective>>(gap::generator<mx::OMPDistributeSimdDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::CXXConstructionKind>(mx::CXXConstructionKind) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Attr>>(gap::generator<mx::Attr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<PackedAttrId>(PackedAttrId) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DivFOp>>(std::optional<mx::ir::hl::DivFOp>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UndefineMacroDirective>>(std::optional<mx::UndefineMacroDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnyX86InterruptAttr>>(std::optional<mx::AnyX86InterruptAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ModeAttr>>(std::optional<mx::ModeAttr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyRefExpr>(mx::ObjCPropertyRefExpr) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDistributeSimdDirective>>(std::optional<mx::OMPDistributeSimdDirective>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCPropertyRefExpr>>(std::optional<mx::ObjCPropertyRefExpr>) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::File>(mx::File) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<mx::Bits>(mx::Bits) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCPropertyRefExpr>>(gap::generator<mx::ObjCPropertyRefExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExcludeFromExplicitInstantiationAttrSpelling>::Type>
+from_python<mx::ExcludeFromExplicitInstantiationAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::File>>(std::optional<mx::File>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnavailableAttrImplicitReason>::Type>
+from_python<mx::UnavailableAttrImplicitReason>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXNewInitializationStyle>(mx::CXXNewInitializationStyle) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquiredBeforeAttr>::Type>
+from_python<mx::AcquiredBeforeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DivSOp>(mx::ir::hl::DivSOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DecltypeType>::Type>
+from_python<mx::DecltypeType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDistributeSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDistributeSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprConstantExprKind>::Type>
+from_python<mx::ExprConstantExprKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DivSAssignOp>(mx::ir::hl::DivSAssignOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnavailableAttrSpelling>::Type>
+from_python<mx::UnavailableAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DivSAssignOp>>(std::optional<mx::ir::hl::DivSAssignOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquiredAfterAttr>::Type>
+from_python<mx::AcquiredAfterAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CallingConv>(mx::CallingConv) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinType>::Type>
+from_python<mx::BuiltinType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CanThrowResult>(mx::CanThrowResult) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprLValueClassification>::Type>
+from_python<mx::ExprLValueClassification>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CapturedRegionKind>(mx::CapturedRegionKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UninitializedAttrSpelling>::Type>
+from_python<mx::UninitializedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OtherMacroDirective>(mx::OtherMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Decl>>::Type>
+from_python<std::optional<mx::Decl>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPAtomicDirective>(mx::OMPAtomicDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquireHandleAttr>::Type>
+from_python<mx::AcquireHandleAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OtherMacroDirective>>(gap::generator<mx::OtherMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BlockPointerType>::Type>
+from_python<mx::BlockPointerType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AnalyzerNoReturnAttr>(mx::AnalyzerNoReturnAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Stmt>>::Type>
+from_python<std::optional<mx::Stmt>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskyieldDirective>(mx::OMPTaskyieldDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprNullPointerConstantKind>::Type>
+from_python<mx::ExprNullPointerConstantKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AllocSizeAttr>(mx::AllocSizeAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnlikelyAttrSpelling>::Type>
+from_python<mx::UnlikelyAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPAtomicDirective>>(gap::generator<mx::OMPAtomicDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprNullPointerConstantValueDependence>::Type>
+from_python<mx::ExprNullPointerConstantValueDependence>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnalyzerNoReturnAttr>>(gap::generator<mx::AnalyzerNoReturnAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnsafeBufferUsageAttrSpelling>::Type>
+from_python<mx::UnsafeBufferUsageAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CastKind>(mx::CastKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquireCapabilityAttr>::Type>
+from_python<mx::AcquireCapabilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LoopHintAttr>(mx::LoopHintAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BitIntType>::Type>
+from_python<mx::BitIntType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InitSegAttr>(mx::InitSegAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprSideEffectsKind>::Type>
+from_python<mx::ExprSideEffectsKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LoopHintAttr>>(gap::generator<mx::LoopHintAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnusedAttrSpelling>::Type>
+from_python<mx::UnusedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CharacterLiteralKind>(mx::CharacterLiteralKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AVRSignalAttr>::Type>
+from_python<mx::AVRSignalAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ClangABI>(mx::ClangABI) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFTagAttributedType>::Type>
+from_python<mx::BTFTagAttributedType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCPropertyRefExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCPropertyRefExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprisModifiableLvalueResult>::Type>
+from_python<mx::ExprisModifiableLvalueResult>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwitchStmt>(mx::SwitchStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UseHandleAttrSpelling>::Type>
+from_python<mx::UseHandleAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DivSOp>>(std::optional<mx::ir::hl::DivSOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AVRInterruptAttr>::Type>
+from_python<mx::AVRInterruptAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CommentKind>(mx::CommentKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AttributedType>::Type>
+from_python<mx::AttributedType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DefaultStmt>(mx::DefaultStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExternalSourceSymbolAttrSpelling>::Type>
+from_python<mx::ExternalSourceSymbolAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Macro>(mx::Macro) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsedAttrSpelling>::Type>
+from_python<mx::UsedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwitchStmt>>(gap::generator<mx::SwitchStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FallThroughAttrSpelling>::Type>
+from_python<mx::FallThroughAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ComparisonCategoryResult>(mx::ComparisonCategoryResult) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UserDefinedLiteralLiteralOperatorKind>::Type>
+from_python<mx::UserDefinedLiteralLiteralOperatorKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPAtomicDirective>>(std::optional<mx::OMPAtomicDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ARMInterruptAttr>::Type>
+from_python<mx::ARMInterruptAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnalyzerNoReturnAttr>>(std::optional<mx::AnalyzerNoReturnAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AtomicType>::Type>
+from_python<mx::AtomicType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedMacroId>(PackedMacroId) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FastCallAttrSpelling>::Type>
+from_python<mx::FastCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LoopHintAttr>>(std::optional<mx::LoopHintAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingIfExistsAttrSpelling>::Type>
+from_python<mx::UsingIfExistsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPAtomicDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPAtomicDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUWavesPerEUAttr>::Type>
+from_python<mx::AMDGPUWavesPerEUAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Token>>(gap::generator<mx::Token>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IncompleteArrayType>::Type>
+from_python<mx::IncompleteArrayType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OtherMacroDirective>>(std::optional<mx::OtherMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FinalAttrSpelling>::Type>
+from_python<mx::FinalAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DivUOp>(mx::ir::hl::DivUOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UuidAttrSpelling>::Type>
+from_python<mx::UuidAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DivUAssignOp>(mx::ir::hl::DivUAssignOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUNumVGPRAttr>::Type>
+from_python<mx::AMDGPUNumVGPRAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Macro>>(gap::generator<mx::Macro>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentSizedArrayType>::Type>
+from_python<mx::DependentSizedArrayType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ComparisonCategoryType>(mx::ComparisonCategoryType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FlagEnumAttrSpelling>::Type>
+from_python<mx::FlagEnumAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DivUAssignOp>>(std::optional<mx::ir::hl::DivUAssignOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VarDeclDefinitionKind>::Type>
+from_python<mx::VarDeclDefinitionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwitchStmt>>(std::optional<mx::SwitchStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::File>::Type>
+from_python<mx::File>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CompilingModuleKind>(mx::CompilingModuleKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FlattenAttrSpelling>::Type>
+from_python<mx::FlattenAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDistributeParallelForSimdDirective>(mx::OMPDistributeParallelForSimdDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VarDeclInitializationStyle>::Type>
+from_python<mx::VarDeclInitializationStyle>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDistributeDirective>(mx::OMPDistributeDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Attr>>::Type>
+from_python<std::optional<mx::Attr>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDistributeParallelForSimdDirective>>(gap::generator<mx::OMPDistributeParallelForSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUNumSGPRAttr>::Type>
+from_python<mx::AMDGPUNumSGPRAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SwitchStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::SwitchStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstantArrayType>::Type>
+from_python<mx::ConstantArrayType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ComplexRangeKind>(mx::ComplexRangeKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FormatArgAttrSpelling>::Type>
+from_python<mx::FormatArgAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstantResultStorageKind>(mx::ConstantResultStorageKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VarDeclTLSKind>::Type>
+from_python<mx::VarDeclTLSKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstexprSpecKind>(mx::ConstexprSpecKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUKernelCallAttr>::Type>
+from_python<mx::AMDGPUKernelCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoreFoundationABI>(mx::CoreFoundationABI) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AdjustedType>::Type>
+from_python<mx::AdjustedType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AlwaysDestroyAttr>(mx::AlwaysDestroyAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FormatAttrSpelling>::Type>
+from_python<mx::FormatAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroKind>(mx::MacroKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VecReturnAttrSpelling>::Type>
+from_python<mx::VecReturnAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AllocAlignAttr>(mx::AllocAlignAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUFlatWorkGroupSizeAttr>::Type>
+from_python<mx::AMDGPUFlatWorkGroupSizeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlwaysDestroyAttr>>(gap::generator<mx::AlwaysDestroyAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DecayedType>::Type>
+from_python<mx::DecayedType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DataPositionTy>(mx::DataPositionTy) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionDeclTemplatedKind>::Type>
+from_python<mx::FunctionDeclTemplatedKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConditionalMacroDirective>(mx::ConditionalMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VectorCallAttrSpelling>::Type>
+from_python<mx::VectorCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DivUOp>>(std::optional<mx::ir::hl::DivUOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionReturnThunksAttrKind>::Type>
+from_python<mx::FunctionReturnThunksAttrKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeductionCandidate>(mx::DeductionCandidate) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityAttrSpelling>::Type>
+from_python<mx::VisibilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EndIfMacroDirective>(mx::EndIfMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AArch64VectorPcsAttr>::Type>
+from_python<mx::AArch64VectorPcsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConditionalMacroDirective>>(gap::generator<mx::ConditionalMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeWithKeyword>::Type>
+from_python<mx::TypeWithKeyword>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DefaultArgKind>(mx::DefaultArgKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionReturnThunksAttrSpelling>::Type>
+from_python<mx::FunctionReturnThunksAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LoaderUninitializedAttr>(mx::LoaderUninitializedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityAttrVisibilityType>::Type>
+from_python<mx::VisibilityAttrVisibilityType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDistributeParallelForSimdDirective>>(std::optional<mx::OMPDistributeParallelForSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AArch64SVEPcsAttr>::Type>
+from_python<mx::AArch64SVEPcsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IBOutletAttr>(mx::IBOutletAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ElaboratedType>::Type>
+from_python<mx::ElaboratedType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LoaderUninitializedAttr>>(gap::generator<mx::LoaderUninitializedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionTypeAArch64SMETypeAttributes>::Type>
+from_python<mx::FunctionTypeAArch64SMETypeAttributes>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCInterfaceDecl>(mx::ObjCInterfaceDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WarnUnusedAttrSpelling>::Type>
+from_python<mx::WarnUnusedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCInterfaceDecl>>(gap::generator<mx::ObjCInterfaceDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ZeroCallUsedRegsAttr>::Type>
+from_python<mx::ZeroCallUsedRegsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDistributeParallelForSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDistributeParallelForSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentTemplateSpecializationType>::Type>
+from_python<mx::DependentTemplateSpecializationType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DefaultCallingConvention>(mx::DefaultCallingConvention) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionTypeArmStateValue>::Type>
+from_python<mx::FunctionTypeArmStateValue>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCContainerDecl>(mx::ObjCContainerDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WarnUnusedResultAttrSpelling>::Type>
+from_python<mx::WarnUnusedResultAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DoOp>(mx::ir::hl::DoOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GNUInlineAttrSpelling>::Type>
+from_python<mx::GNUInlineAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtDefsFieldDecl>>(gap::generator<mx::ObjCAtDefsFieldDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakAttrSpelling>::Type>
+from_python<mx::WeakAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXMethodDecl>(mx::CXXMethodDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::XRayLogArgsAttr>::Type>
+from_python<mx::XRayLogArgsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXConstructorDecl>>(gap::generator<mx::CXXConstructorDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentNameType>::Type>
+from_python<mx::DependentNameType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionDecl>(mx::FunctionDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GuardedVarAttrSpelling>::Type>
+from_python<mx::GuardedVarAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::AbstractConditionalOperator, mx::ir::Operation>>>(gap::generator<std::pair<mx::AbstractConditionalOperator, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakImportAttrSpelling>::Type>
+from_python<mx::WeakImportAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionDecl>>(gap::generator<mx::FunctionDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::XRayInstrumentAttr>::Type>
+from_python<mx::XRayInstrumentAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangRelroSectionAttr>>(gap::generator<mx::PragmaClangRelroSectionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VectorType>::Type>
+from_python<mx::VectorType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MatrixTransposeOp>>(std::optional<mx::ir::llvm::MatrixTransposeOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HIPManagedAttrSpelling>::Type>
+from_python<mx::HIPManagedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoDestroyAttr>>(gap::generator<mx::NoDestroyAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakRefAttrSpelling>::Type>
+from_python<mx::WeakRefAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtDefsFieldDecl>>(std::optional<mx::ObjCAtDefsFieldDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::X86ForceAlignArgPointerAttr>::Type>
+from_python<mx::X86ForceAlignArgPointerAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCAtDefsFieldDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCAtDefsFieldDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExtVectorType>::Type>
+from_python<mx::ExtVectorType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionDecl>>(std::optional<mx::FunctionDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLParamModifierAttrSpelling>::Type>
+from_python<mx::HLSLParamModifierAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangRelroSectionAttr>>(std::optional<mx::PragmaClangRelroSectionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyExportNameAttrSpelling>::Type>
+from_python<mx::WebAssemblyExportNameAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MaxNumOp>(mx::ir::llvm::MaxNumOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLShaderAttrShaderType>::Type>
+from_python<mx::HLSLShaderAttrShaderType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FunctionDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::FunctionDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyImportModuleAttrSpelling>::Type>
+from_python<mx::WebAssemblyImportModuleAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MaxNumOp>>(std::optional<mx::ir::llvm::MaxNumOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WorkGroupSizeHintAttr>::Type>
+from_python<mx::WorkGroupSizeHintAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoDestroyAttr>>(std::optional<mx::NoDestroyAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingType>::Type>
+from_python<mx::UsingType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MaximumOp>(mx::ir::llvm::MaximumOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HotAttrSpelling>::Type>
+from_python<mx::HotAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MaximumOp>>(std::optional<mx::ir::llvm::MaximumOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyImportNameAttrSpelling>::Type>
+from_python<mx::WebAssemblyImportNameAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConditionalOperator>>(gap::generator<mx::ConditionalOperator>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyImportNameAttr>::Type>
+from_python<mx::WebAssemblyImportNameAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangDataSectionAttr>>(gap::generator<mx::PragmaClangDataSectionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingShadowDecl>::Type>
+from_python<mx::UsingShadowDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoDebugAttr>>(gap::generator<mx::NoDebugAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IBActionAttrSpelling>::Type>
+from_python<mx::IBActionAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MemcpyInlineOp>(mx::ir::llvm::MemcpyInlineOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::X86ForceAlignArgPointerAttrSpelling>::Type>
+from_python<mx::X86ForceAlignArgPointerAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MemcpyInlineOp>>(std::optional<mx::ir::llvm::MemcpyInlineOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AllocSizeAttrSpelling>::Type>
+from_python<mx::AllocSizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UsingPackDecl>(mx::UsingPackDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyImportModuleAttr>::Type>
+from_python<mx::WebAssemblyImportModuleAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclarativeDirectiveValueDecl>>(gap::generator<mx::OMPDeclarativeDirectiveValueDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BaseUsingDecl>::Type>
+from_python<mx::BaseUsingDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConditionalOperator>>(std::optional<mx::ConditionalOperator>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IBOutletAttrSpelling>::Type>
+from_python<mx::IBOutletAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MemcpyOp>(mx::ir::llvm::MemcpyOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::XRayInstrumentAttrSpelling>::Type>
+from_python<mx::XRayInstrumentAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MemcpyOp>>(std::optional<mx::ir::llvm::MemcpyOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::TemplateArgument>>::Type>
+from_python<std::optional<mx::TemplateArgument>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangDataSectionAttr>>(std::optional<mx::PragmaClangDataSectionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IBOutletCollectionAttrSpelling>::Type>
+from_python<mx::IBOutletCollectionAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoDebugAttr>>(std::optional<mx::NoDebugAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::XRayLogArgsAttrSpelling>::Type>
+from_python<mx::XRayLogArgsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ConditionalOperator, mx::ir::Operation>>>(gap::generator<std::pair<mx::ConditionalOperator, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyExportNameAttr>::Type>
+from_python<mx::WebAssemblyExportNameAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MemmoveOp>(mx::ir::llvm::MemmoveOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedUsingType>::Type>
+from_python<mx::UnresolvedUsingType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionTemplateDecl>(mx::FunctionTemplateDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IFuncAttrSpelling>::Type>
+from_python<mx::IFuncAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionTemplateDecl>>(std::optional<mx::FunctionTemplateDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ZeroCallUsedRegsAttrSpelling>::Type>
+from_python<mx::ZeroCallUsedRegsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MemmoveOp>>(std::optional<mx::ir::llvm::MemmoveOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakRefAttr>::Type>
+from_python<mx::WeakRefAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclarativeDirectiveValueDecl>>(std::optional<mx::OMPDeclarativeDirectiveValueDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryTransformType>::Type>
+from_python<mx::UnaryTransformType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionTemplateDecl>>(gap::generator<mx::FunctionTemplateDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitCastExprOnStack>::Type>
+from_python<mx::ImplicitCastExprOnStack>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDeclarativeDirectiveValueDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDeclarativeDirectiveValueDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind>::Type>
+from_python<mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MemsetOp>(mx::ir::llvm::MemsetOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateParameterList>::Type>
+from_python<mx::TemplateParameterList>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MemsetOp>>(std::optional<mx::ir::llvm::MemsetOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakImportAttr>::Type>
+from_python<mx::WeakImportAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoCommonAttr>(mx::NoCommonAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedUsingTypenameDecl>::Type>
+from_python<mx::UnresolvedUsingTypenameDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangBSSSectionAttr>(mx::PragmaClangBSSSectionAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InitPriorityAttrSpelling>::Type>
+from_python<mx::InitPriorityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PcsAttr>(mx::PcsAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ASTDumpOutputFormat>::Type>
+from_python<mx::ASTDumpOutputFormat>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoCommonAttr>>(gap::generator<mx::NoCommonAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IntelOclBiccAttrSpelling>::Type>
+from_python<mx::IntelOclBiccAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangBSSSectionAttr>>(gap::generator<mx::PragmaClangBSSSectionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AccessSpecifier>::Type>
+from_python<mx::AccessSpecifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MinNumOp>(mx::ir::llvm::MinNumOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WeakAttr>::Type>
+from_python<mx::WeakAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MinNumOp>>(std::optional<mx::ir::llvm::MinNumOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypedefType>::Type>
+from_python<mx::TypedefType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FunctionTemplateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::FunctionTemplateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InternalLinkageAttrSpelling>::Type>
+from_python<mx::InternalLinkageAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoCommonAttr>>(std::optional<mx::NoCommonAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AddrSpaceMapMangling>::Type>
+from_python<mx::AddrSpaceMapMangling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangBSSSectionAttr>>(std::optional<mx::PragmaClangBSSSectionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WarnUnusedResultAttr>::Type>
+from_python<mx::WarnUnusedResultAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MinimumOp>(mx::ir::llvm::MinimumOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeOfType>::Type>
+from_python<mx::TypeOfType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MinimumOp>>(std::optional<mx::ir::llvm::MinimumOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LTOVisibilityPublicAttrSpelling>::Type>
+from_python<mx::LTOVisibilityPublicAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BinaryConditionalOperator>>(gap::generator<mx::BinaryConditionalOperator>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignRequirementKind>::Type>
+from_python<mx::AlignRequirementKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::RoundToNearbyIntOp>(mx::ir::llvm::RoundToNearbyIntOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WarnUnusedAttr>::Type>
+from_python<mx::WarnUnusedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::RoundToNearbyIntOp>>(std::optional<mx::ir::llvm::RoundToNearbyIntOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeOfExprType>::Type>
+from_python<mx::TypeOfExprType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareMapperDecl>>(gap::generator<mx::OMPDeclareMapperDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LeafAttrSpelling>::Type>
+from_python<mx::LeafAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoAliasAttr>(mx::NoAliasAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AltivecSrcCompatKind>::Type>
+from_python<mx::AltivecSrcCompatKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoAliasAttr>>(gap::generator<mx::NoAliasAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LifetimeBoundAttrSpelling>::Type>
+from_python<mx::LifetimeBoundAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BinaryConditionalOperator>>(std::optional<mx::BinaryConditionalOperator>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArgumentKind>::Type>
+from_python<mx::ArgumentKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PointerAttr>(mx::PointerAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityAttr>::Type>
+from_python<mx::VisibilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PointerAttr>>(gap::generator<mx::PointerAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SEHTryStmt>::Type>
+from_python<mx::SEHTryStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::BinaryConditionalOperator, mx::ir::Operation>>>(gap::generator<std::pair<mx::BinaryConditionalOperator, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LikelyAttrSpelling>::Type>
+from_python<mx::LikelyAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::PowIOp>(mx::ir::llvm::PowIOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArraySizeModifier>::Type>
+from_python<mx::ArraySizeModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::NoAliasScopeDeclOp>(mx::ir::llvm::NoAliasScopeDeclOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VectorCallAttr>::Type>
+from_python<mx::VectorCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::NoAliasScopeDeclOp>>(std::optional<mx::ir::llvm::NoAliasScopeDeclOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SEHExceptStmt>::Type>
+from_python<mx::SEHExceptStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareMapperDecl>>(std::optional<mx::OMPDeclareMapperDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LoaderUninitializedAttrSpelling>::Type>
+from_python<mx::LoaderUninitializedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoAliasAttr>>(std::optional<mx::NoAliasAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayTypeTrait>::Type>
+from_python<mx::ArrayTypeTrait>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDeclareMapperDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDeclareMapperDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Index>::Type>
+from_python<mx::Index>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PointerAttr>>(std::optional<mx::PointerAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VecTypeHintAttr>::Type>
+from_python<mx::VecTypeHintAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FPowOp>(mx::ir::llvm::FPowOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CompoundStmt>::Type>
+from_python<mx::CompoundStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::PowIOp>>(std::optional<mx::ir::llvm::PowIOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LoopHintAttrLoopHintState>::Type>
+from_python<mx::LoopHintAttrLoopHintState>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NakedAttr>(mx::NakedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AtomicScopeModelKind>::Type>
+from_python<mx::AtomicScopeModelKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsAutoreleasedAttr>(mx::NSReturnsAutoreleasedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUKernelCallAttrSpelling>::Type>
+from_python<mx::AMDGPUKernelCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FPowOp>>(std::optional<mx::ir::llvm::FPowOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LoopHintAttrOptionType>::Type>
+from_python<mx::LoopHintAttrOptionType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NakedAttr>>(gap::generator<mx::NakedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AutoTypeKeyword>::Type>
+from_python<mx::AutoTypeKeyword>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PascalAttr>(mx::PascalAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VecReturnAttr>::Type>
+from_python<mx::VecReturnAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PcsAttr>>(gap::generator<mx::PcsAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SEHFinallyStmt>::Type>
+from_python<mx::SEHFinallyStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VAArgExpr>(mx::VAArgExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LoopHintAttrSpelling>::Type>
+from_python<mx::LoopHintAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::PrefetchOp>(mx::ir::llvm::PrefetchOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailabilityResult>::Type>
+from_python<mx::AvailabilityResult>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnaryExprOrTypeTraitExpr>(mx::UnaryExprOrTypeTraitExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UuidAttr>::Type>
+from_python<mx::UuidAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VAArgExpr>>(gap::generator<mx::VAArgExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SEHLeaveStmt>::Type>
+from_python<mx::SEHLeaveStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::PrefetchOp>>(std::optional<mx::ir::llvm::PrefetchOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::M68kRTDAttrSpelling>::Type>
+from_python<mx::M68kRTDAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NakedAttr>>(std::optional<mx::NakedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BinaryOperatorKind>::Type>
+from_python<mx::BinaryOperatorKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PcsAttr>>(std::optional<mx::PcsAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnStmt>::Type>
+from_python<mx::ReturnStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstructorUsingShadowDecl>(mx::ConstructorUsingShadowDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSGuidDecl>::Type>
+from_python<mx::MSGuidDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UsingDirectiveDecl>(mx::UsingDirectiveDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MIGServerRoutineAttrSpelling>::Type>
+from_python<mx::MIGServerRoutineAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstructorUsingShadowDecl>>(gap::generator<mx::ConstructorUsingShadowDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Bits>::Type>
+from_python<mx::Bits>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::PtrAnnotationOp>(mx::ir::llvm::PtrAnnotationOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSABIAttrSpelling>::Type>
+from_python<mx::MSABIAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VAArgExpr>>(std::optional<mx::VAArgExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConstructionKind>::Type>
+from_python<mx::CXXConstructionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::PtrAnnotationOp>>(std::optional<mx::ir::llvm::PtrAnnotationOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingIfExistsAttr>::Type>
+from_python<mx::UsingIfExistsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::VAArgExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::VAArgExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCForCollectionStmt>::Type>
+from_python<mx::ObjCForCollectionStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::RoundToIntOp>(mx::ir::llvm::RoundToIntOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RegexQueryMatch>::Type>
+from_python<mx::RegexQueryMatch>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXMethodDecl>>(gap::generator<mx::CXXMethodDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSInheritanceAttrSpelling>::Type>
+from_python<mx::MSInheritanceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NVPTXKernelAttr>(mx::NVPTXKernelAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNewInitializationStyle>::Type>
+from_python<mx::CXXNewInitializationStyle>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsNotRetainedAttr>(mx::NSReturnsNotRetainedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsedAttr>::Type>
+from_python<mx::UsedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NVPTXKernelAttr>>(gap::generator<mx::NVPTXKernelAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAutoreleasePoolStmt>::Type>
+from_python<mx::ObjCAutoreleasePoolStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::RoundToIntOp>>(std::optional<mx::ir::llvm::RoundToIntOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSP430InterruptAttrSpelling>::Type>
+from_python<mx::MSP430InterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstructorUsingShadowDecl>>(std::optional<mx::ConstructorUsingShadowDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CallingConv>::Type>
+from_python<mx::CallingConv>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PatchableFunctionEntryAttr>(mx::PatchableFunctionEntryAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnusedAttr>::Type>
+from_python<mx::UnusedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParamTypestateAttr>(mx::ParamTypestateAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtTryStmt>::Type>
+from_python<mx::ObjCAtTryStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PatchableFunctionEntryAttr>>(gap::generator<mx::PatchableFunctionEntryAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSStructAttrSpelling>::Type>
+from_python<mx::MSStructAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ConstructorUsingShadowDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ConstructorUsingShadowDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CanThrowResult>::Type>
+from_python<mx::CanThrowResult>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXMethodDecl>>(std::optional<mx::CXXMethodDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MayAliasAttrSpelling>::Type>
+from_python<mx::MayAliasAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::RoundToNearestEvenOp>(mx::ir::llvm::RoundToNearestEvenOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedRegionKind>::Type>
+from_python<mx::CapturedRegionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::RoundToNearestEvenOp>>(std::optional<mx::ir::llvm::RoundToNearestEvenOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnsafeBufferUsageAttr>::Type>
+from_python<mx::UnsafeBufferUsageAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NVPTXKernelAttr>>(std::optional<mx::NVPTXKernelAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtFinallyStmt>::Type>
+from_python<mx::ObjCAtFinallyStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXMethodDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXMethodDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MaybeUndefAttrSpelling>::Type>
+from_python<mx::MaybeUndefAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PatchableFunctionEntryAttr>>(std::optional<mx::PatchableFunctionEntryAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CastKind>::Type>
+from_python<mx::CastKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SAddSatOp>(mx::ir::llvm::SAddSatOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UninitializedAttr>::Type>
+from_python<mx::UninitializedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::RoundToNearestOp>(mx::ir::llvm::RoundToNearestOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtCatchStmt>::Type>
+from_python<mx::ObjCAtCatchStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::RoundToNearestOp>>(std::optional<mx::ir::llvm::RoundToNearestOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MicroMipsAttrSpelling>::Type>
+from_python<mx::MicroMipsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSReturnsRetainedAttr>>(gap::generator<mx::NSReturnsRetainedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CharacterLiteralKind>::Type>
+from_python<mx::CharacterLiteralKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsRetainedAttr>(mx::NSReturnsRetainedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnavailableAttr>::Type>
+from_python<mx::UnavailableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypoExpr>(mx::TypoExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtThrowStmt>::Type>
+from_python<mx::ObjCAtThrowStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnaryOperator>(mx::UnaryOperator) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MinSizeAttrSpelling>::Type>
+from_python<mx::MinSizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TransparentUnionAttr>>(std::optional<mx::TransparentUnionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ClangABI>::Type>
+from_python<mx::ClangABI>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLGlobalDeviceAddressSpaceAttr>>(std::optional<mx::OpenCLGlobalDeviceAddressSpaceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MinVectorWidthAttrSpelling>::Type>
+from_python<mx::MinVectorWidthAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCIndirectCopyRestoreExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCIndirectCopyRestoreExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CommentKind>::Type>
+from_python<mx::CommentKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CalledOnceAttr>>(gap::generator<mx::CalledOnceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeVisibilityAttr>::Type>
+from_python<mx::TypeVisibilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDirective>>(gap::generator<mx::OMPTeamsDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtSynchronizedStmt>::Type>
+from_python<mx::ObjCAtSynchronizedStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ThisCallAttr>>(gap::generator<mx::ThisCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::vector<std::variant<UserToken, mx::Token>>>::Type>
+from_python<std::vector<std::variant<UserToken, mx::Token>>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLGlobalAddressSpaceAttr>>(gap::generator<mx::OpenCLGlobalAddressSpaceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Mips16AttrSpelling>::Type>
+from_python<mx::Mips16AttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CalledOnceAttr>>(std::optional<mx::CalledOnceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ComparisonCategoryResult>::Type>
+from_python<mx::ComparisonCategoryResult>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDirective>>(std::optional<mx::OMPTeamsDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeTagForDatatypeAttr>::Type>
+from_python<mx::TypeTagForDatatypeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTeamsDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTeamsDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPExecutableDirective>::Type>
+from_python<mx::OMPExecutableDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ThisCallAttr>>(std::optional<mx::ThisCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsInterruptAttrInterruptType>::Type>
+from_python<mx::MipsInterruptAttrInterruptType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLGlobalAddressSpaceAttr>>(std::optional<mx::OpenCLGlobalAddressSpaceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ComparisonCategoryType>::Type>
+from_python<mx::ComparisonCategoryType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCEncodeExpr>>(gap::generator<mx::ObjCEncodeExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TryAcquireCapabilityAttr>::Type>
+from_python<mx::TryAcquireCapabilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinAliasAttr>>(gap::generator<mx::BuiltinAliasAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedStmt>::Type>
+from_python<mx::CapturedStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TestTypestateAttr>>(gap::generator<mx::TestTypestateAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsInterruptAttrSpelling>::Type>
+from_python<mx::MipsInterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCEncodeExpr>>(std::optional<mx::ObjCEncodeExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CompilingModuleKind>::Type>
+from_python<mx::CompilingModuleKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLGenericAddressSpaceAttr>>(gap::generator<mx::OpenCLGenericAddressSpaceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsLongCallAttrSpelling>::Type>
+from_python<mx::MipsLongCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinAliasAttr>>(std::optional<mx::BuiltinAliasAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ComplexRangeKind>::Type>
+from_python<mx::ComplexRangeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCEncodeExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCEncodeExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TrivialABIAttr>::Type>
+from_python<mx::TrivialABIAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskyieldDirective>>(gap::generator<mx::OMPTaskyieldDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedDecl>::Type>
+from_python<mx::CapturedDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TestTypestateAttr>>(std::optional<mx::TestTypestateAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsShortCallAttrSpelling>::Type>
+from_python<mx::MipsShortCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLGenericAddressSpaceAttr>>(std::optional<mx::OpenCLGenericAddressSpaceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstantResultStorageKind>::Type>
+from_python<mx::ConstantResultStorageKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateTypeParmType>(mx::TemplateTypeParmType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TransparentUnionAttr>::Type>
+from_python<mx::TransparentUnionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TagType>(mx::TagType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPErrorDirective>::Type>
+from_python<mx::OMPErrorDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateTypeParmType>>(gap::generator<mx::TemplateTypeParmType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ModeAttrSpelling>::Type>
+from_python<mx::ModeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskyieldDirective>>(std::optional<mx::OMPTaskyieldDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstexprSpecKind>::Type>
+from_python<mx::ConstexprSpecKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTaskyieldDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTaskyieldDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ThisCallAttr>::Type>
+from_python<mx::ThisCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TargetVersionAttr>(mx::TargetVersionAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDispatchDirective>::Type>
+from_python<mx::OMPDispatchDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateTypeParmType>>(std::optional<mx::TemplateTypeParmType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MustTailAttrSpelling>::Type>
+from_python<mx::MustTailAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TargetVersionAttr>>(gap::generator<mx::TargetVersionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoreFoundationABI>::Type>
+from_python<mx::CoreFoundationABI>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLConstantAddressSpaceAttr>(mx::OpenCLConstantAddressSpaceAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSConsumedAttrSpelling>::Type>
+from_python<mx::NSConsumedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLConstantAddressSpaceAttr>>(gap::generator<mx::OpenCLConstantAddressSpaceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DataPositionTy>::Type>
+from_python<mx::DataPositionTy>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCDictionaryLiteral>>(gap::generator<mx::ObjCDictionaryLiteral>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TestTypestateAttr>::Type>
+from_python<mx::TestTypestateAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TargetVersionAttr>>(std::optional<mx::TargetVersionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDepobjDirective>::Type>
+from_python<mx::OMPDepobjDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateTypeParmDecl>(mx::TemplateTypeParmDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSConsumesSelfAttrSpelling>::Type>
+from_python<mx::NSConsumesSelfAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateTypeParmDecl>>(std::optional<mx::TemplateTypeParmDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeductionCandidate>::Type>
+from_python<mx::DeductionCandidate>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLConstantAddressSpaceAttr>>(std::optional<mx::OpenCLConstantAddressSpaceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetVersionAttr>::Type>
+from_python<mx::TargetVersionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateTypeParmDecl>>(gap::generator<mx::TemplateTypeParmDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCriticalDirective>::Type>
+from_python<mx::OMPCriticalDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCDictionaryLiteral>>(std::optional<mx::ObjCDictionaryLiteral>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsAutoreleasedAttrSpelling>::Type>
+from_python<mx::NSReturnsAutoreleasedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCDictionaryLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCDictionaryLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DefaultArgKind>::Type>
+from_python<mx::DefaultArgKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskwaitDirective>(mx::OMPTaskwaitDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetClonesAttr>::Type>
+from_python<mx::TargetClonesAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskDirective>(mx::OMPTaskDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCancellationPointDirective>::Type>
+from_python<mx::OMPCancellationPointDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskwaitDirective>>(gap::generator<mx::OMPTaskwaitDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsNotRetainedAttrSpelling>::Type>
+from_python<mx::NSReturnsNotRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TargetClonesAttr>(mx::TargetClonesAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DefaultCallingConvention>::Type>
+from_python<mx::DefaultCallingConvention>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCKindOfAttr>(mx::ObjCKindOfAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsRetainedAttrSpelling>::Type>
+from_python<mx::NSReturnsRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TargetClonesAttr>>(gap::generator<mx::TargetClonesAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DefaultVisiblityExportMapping>::Type>
+from_python<mx::DefaultVisiblityExportMapping>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TemplateTypeParmDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TemplateTypeParmDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetAttr>::Type>
+from_python<mx::TargetAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCKindOfAttr>>(gap::generator<mx::ObjCKindOfAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCancelDirective>::Type>
+from_python<mx::OMPCancelDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskwaitDirective>>(std::optional<mx::OMPTaskwaitDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NVPTXKernelAttrSpelling>::Type>
+from_python<mx::NVPTXKernelAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TargetClonesAttr>>(std::optional<mx::TargetClonesAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DesignatorKind>::Type>
+from_python<mx::DesignatorKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTaskwaitDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTaskwaitDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TLSModelAttr>::Type>
+from_python<mx::TLSModelAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCKindOfAttr>>(std::optional<mx::ObjCKindOfAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPBarrierDirective>::Type>
+from_python<mx::OMPBarrierDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBoxedExpr>(mx::ObjCBoxedExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Macro>>::Type>
+from_python<std::optional<mx::Macro>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCAvailabilityCheckExpr>(mx::ObjCAvailabilityCheckExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NakedAttrSpelling>::Type>
+from_python<mx::NakedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBoxedExpr>>(gap::generator<mx::ObjCBoxedExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnosticLevelMask>::Type>
+from_python<mx::DiagnosticLevelMask>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TargetAttr>(mx::TargetAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SysVABIAttr>::Type>
+from_python<mx::SysVABIAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SysVABIAttr>(mx::SysVABIAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPAtomicDirective>::Type>
+from_python<mx::OMPAtomicDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCInertUnsafeUnretainedAttr>(mx::ObjCInertUnsafeUnretainedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NamedDeclExplicitVisibilityKind>::Type>
+from_python<mx::NamedDeclExplicitVisibilityKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TargetAttr>>(gap::generator<mx::TargetAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ElaboratedTypeKeyword>::Type>
+from_python<mx::ElaboratedTypeKeyword>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoDerefAttr>(mx::NoDerefAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoBuiltinAttrSpelling>::Type>
+from_python<mx::NoBuiltinAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCInertUnsafeUnretainedAttr>>(gap::generator<mx::ObjCInertUnsafeUnretainedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EscapeChar>::Type>
+from_python<mx::EscapeChar>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBoxedExpr>>(std::optional<mx::ObjCBoxedExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftPrivateAttr>::Type>
+from_python<mx::SwiftPrivateAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCBoxedExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCBoxedExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDirective>::Type>
+from_python<mx::OMPTeamsDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TargetAttr>>(std::optional<mx::TargetAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoCommonAttrSpelling>::Type>
+from_python<mx::NoCommonAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCInertUnsafeUnretainedAttr>>(std::optional<mx::ObjCInertUnsafeUnretainedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExceptionHandlingKind>::Type>
+from_python<mx::ExceptionHandlingKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskgroupDirective>(mx::OMPTaskgroupDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftNewTypeAttr>::Type>
+from_python<mx::SwiftNewTypeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetUpdateDirective>(mx::OMPTargetUpdateDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskyieldDirective>::Type>
+from_python<mx::OMPTaskyieldDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateSpecializationType>(mx::TemplateSpecializationType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDebugAttrSpelling>::Type>
+from_python<mx::NoDebugAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskgroupDirective>>(gap::generator<mx::OMPTaskgroupDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExceptionSpecificationType>::Type>
+from_python<mx::ExceptionSpecificationType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RecordType>(mx::RecordType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftNameAttr>::Type>
+from_python<mx::SwiftNameAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateSpecializationType>>(gap::generator<mx::TemplateSpecializationType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskwaitDirective>::Type>
+from_python<mx::OMPTaskwaitDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateSpecializationType>>(std::optional<mx::TemplateSpecializationType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDerefAttrSpelling>::Type>
+from_python<mx::NoDerefAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskgroupDirective>>(std::optional<mx::OMPTaskgroupDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExcessPrecisionKind>::Type>
+from_python<mx::ExcessPrecisionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCGCAttr>(mx::ObjCGCAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDestroyAttrSpelling>::Type>
+from_python<mx::NoDestroyAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLParamModifierAttr>(mx::HLSLParamModifierAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExplicitSpecKind>::Type>
+from_python<mx::ExplicitSpecKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCGCAttr>>(gap::generator<mx::ObjCGCAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftImportPropertyAsAccessorsAttr>::Type>
+from_python<mx::SwiftImportPropertyAsAccessorsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TLSModelAttr>(mx::TLSModelAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskgroupDirective>::Type>
+from_python<mx::OMPTaskgroupDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftPrivateAttr>(mx::SwiftPrivateAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDuplicateAttrSpelling>::Type>
+from_python<mx::NoDuplicateAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TLSModelAttr>>(gap::generator<mx::TLSModelAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprDependence>::Type>
+from_python<mx::ExprDependence>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTaskgroupDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTaskgroupDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftImportAsNonGenericAttr>::Type>
+from_python<mx::SwiftImportAsNonGenericAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCGCAttr>>(std::optional<mx::ObjCGCAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskDirective>::Type>
+from_python<mx::OMPTaskDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TLSModelAttr>>(std::optional<mx::TLSModelAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoEscapeAttrSpelling>::Type>
+from_python<mx::NoEscapeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBoolLiteralExpr>(mx::ObjCBoolLiteralExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprObjectKind>::Type>
+from_python<mx::ExprObjectKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnumType>(mx::EnumType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftErrorAttr>::Type>
+from_python<mx::SwiftErrorAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCArrayLiteral>(mx::ObjCArrayLiteral) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetUpdateDirective>::Type>
+from_python<mx::OMPTargetUpdateDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TagType>>(gap::generator<mx::TagType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInlineAttrSpelling>::Type>
+from_python<mx::NoInlineAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBoolLiteralExpr>>(gap::generator<mx::ObjCBoolLiteralExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprOffsets>::Type>
+from_python<mx::ExprOffsets>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::ViewOp>>(std::optional<mx::ir::memref::ViewOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInstrumentFunctionAttrSpelling>::Type>
+from_python<mx::NoInstrumentFunctionAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AdjustedType>>(std::optional<mx::AdjustedType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprValueKind>::Type>
+from_python<mx::ExprValueKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::BrOp>(mx::ir::llvm::BrOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftCallAttr>::Type>
+from_python<mx::SwiftCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::BitcastOp>>(std::optional<mx::ir::llvm::BitcastOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDirective>::Type>
+from_python<mx::OMPTargetTeamsDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::SubViewOp>(mx::ir::memref::SubViewOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMergeAttrSpelling>::Type>
+from_python<mx::NoMergeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::SubViewOp>>(std::optional<mx::ir::memref::SubViewOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExpressionTrait>::Type>
+from_python<mx::ExpressionTrait>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwitchCase>(mx::SwitchCase) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Token>::Type>
+from_python<mx::Token>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwitchCase>>(std::optional<mx::SwitchCase>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftBridgedTypedefAttr>::Type>
+from_python<mx::SwiftBridgedTypedefAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::BrOp>>(std::optional<mx::ir::llvm::BrOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetParallelDirective>::Type>
+from_python<mx::OMPTargetParallelDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXStdInitializerListExpr>>(gap::generator<mx::CXXStdInitializerListExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMicroMipsAttrSpelling>::Type>
+from_python<mx::NoMicroMipsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSDependentExistsStmt>>(gap::generator<mx::MSDependentExistsStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExtKind>::Type>
+from_python<mx::ExtKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwitchCase>>(gap::generator<mx::SwitchCase>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Decl>::Type>
+from_python<mx::Decl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DecayedType>>(gap::generator<mx::DecayedType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftBridgeAttr>::Type>
+from_python<mx::SwiftBridgeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CallOp>(mx::ir::llvm::CallOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetExitDataDirective>::Type>
+from_python<mx::OMPTargetExitDataDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CallIntrinsicOp>(mx::ir::llvm::CallIntrinsicOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMips16AttrSpelling>::Type>
+from_python<mx::NoMips16AttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CallIntrinsicOp>>(std::optional<mx::ir::llvm::CallIntrinsicOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExtendArgsKind>::Type>
+from_python<mx::ExtendArgsKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::Operation>(mx::ir::abi::Operation) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenTreeNode>::Type>
+from_python<mx::TokenTreeNode>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::Operation>>(std::optional<mx::ir::abi::Operation>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoProfileFunctionAttrSpelling>::Type>
+from_python<mx::NoProfileFunctionAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedLookupExpr>>(std::optional<mx::UnresolvedLookupExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FPEvalMethodKind>::Type>
+from_python<mx::FPEvalMethodKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDistributeParallelForDirective>>(gap::generator<mx::OMPDistributeParallelForDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAttrAttr>::Type>
+from_python<mx::SwiftAttrAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DecayedType>>(std::optional<mx::DecayedType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelSectionsDirective>::Type>
+from_python<mx::OMPParallelSectionsDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXStdInitializerListExpr>>(std::optional<mx::CXXStdInitializerListExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<FileLocationCache>::Type>
+from_python<FileLocationCache>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSDependentExistsStmt>>(std::optional<mx::MSDependentExistsStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoRandomizeLayoutAttrSpelling>::Type>
+from_python<mx::NoRandomizeLayoutAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UnresolvedLookupExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::UnresolvedLookupExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FPExceptionModeKind>::Type>
+from_python<mx::FPExceptionModeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::CallArgsOp>(mx::ir::abi::CallArgsOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncNameAttr>::Type>
+from_python<mx::SwiftAsyncNameAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXStdInitializerListExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXStdInitializerListExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetEnterDataDirective>::Type>
+from_python<mx::OMPTargetEnterDataDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::CallArgsOp>>(std::optional<mx::ir::abi::CallArgsOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoReturnAttrSpelling>::Type>
+from_python<mx::NoReturnAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::MSDependentExistsStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::MSDependentExistsStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FPModeKind>::Type>
+from_python<mx::FPModeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SwitchCase, mx::ir::Operation>>>(gap::generator<std::pair<mx::SwitchCase, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncErrorAttr>::Type>
+from_python<mx::SwiftAsyncErrorAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CallOp>>(std::optional<mx::ir::llvm::CallOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetDirective>::Type>
+from_python<mx::OMPTargetDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDistributeParallelForDirective>>(std::optional<mx::OMPDistributeParallelForDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSanitizeAttrSpelling>::Type>
+from_python<mx::NoSanitizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::CallOp>(mx::ir::abi::CallOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Flags>::Type>
+from_python<mx::Flags>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDistributeParallelForDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDistributeParallelForDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSpeculativeLoadHardeningAttrSpelling>::Type>
+from_python<mx::NoSpeculativeLoadHardeningAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::CallExecutionOp>(mx::ir::abi::CallExecutionOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GC>::Type>
+from_python<mx::GC>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::CallExecutionOp>>(std::optional<mx::ir::abi::CallExecutionOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncCallAttr>::Type>
+from_python<mx::SwiftAsyncCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeWithKeyword>>(gap::generator<mx::TypeWithKeyword>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetDataDirective>::Type>
+from_python<mx::OMPTargetDataDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ComdatOp>(mx::ir::llvm::ComdatOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSplitStackAttrSpelling>::Type>
+from_python<mx::NoSplitStackAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ComdatOp>>(std::optional<mx::ir::llvm::ComdatOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GCMode>::Type>
+from_python<mx::GCMode>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeWithKeyword>>(std::optional<mx::TypeWithKeyword>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::string>::Type>
+from_python<std::string>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ComdatSelectorOp>(mx::ir::llvm::ComdatSelectorOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncAttr>::Type>
+from_python<mx::SwiftAsyncAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::CallOp>>(std::optional<mx::ir::abi::CallOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPSingleDirective>::Type>
+from_python<mx::OMPSingleDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ComdatSelectorOp>>(std::optional<mx::ir::llvm::ComdatSelectorOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoStackProtectorAttrSpelling>::Type>
+from_python<mx::NoStackProtectorAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoyieldExpr>(mx::CoyieldExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GPUDefaultStreamKind>::Type>
+from_python<mx::GPUDefaultStreamKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroutineSuspendExpr>>(gap::generator<mx::CoroutineSuspendExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Stmt>::Type>
+from_python<mx::Stmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXScalarValueInitExpr>>(gap::generator<mx::CXXScalarValueInitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StrictGuardStackCheckAttr>::Type>
+from_python<mx::StrictGuardStackCheckAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GotoStmt>(mx::GotoStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPSectionsDirective>::Type>
+from_python<mx::OMPSectionsDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IndirectGotoStmt>>(gap::generator<mx::IndirectGotoStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoThreadSafetyAnalysisAttrSpelling>::Type>
+from_python<mx::NoThreadSafetyAnalysisAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CondBrOp>(mx::ir::llvm::CondBrOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GVALinkage>::Type>
+from_python<mx::GVALinkage>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclarativeDirectiveDecl>(mx::OMPDeclarativeDirectiveDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoThrowAttrSpelling>::Type>
+from_python<mx::NoThrowAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::CallRetsOp>(mx::ir::abi::CallRetsOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GetBuiltinTypeError>::Type>
+from_python<mx::GetBuiltinTypeError>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DefaultStmt>>(gap::generator<mx::DefaultStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StrictFPAttr>::Type>
+from_python<mx::StrictFPAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CondBrOp>>(std::optional<mx::ir::llvm::CondBrOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPSectionDirective>::Type>
+from_python<mx::OMPSectionDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ElaboratedType>(mx::ElaboratedType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoUniqueAddressAttrSpelling>::Type>
+from_python<mx::NoUniqueAddressAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::CallRetsOp>>(std::optional<mx::ir::abi::CallRetsOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLLangStd>::Type>
+from_python<mx::HLSLLangStd>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElaboratedType>>(gap::generator<mx::ElaboratedType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StdCallAttr>::Type>
+from_python<mx::StdCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroutineSuspendExpr>>(std::optional<mx::CoroutineSuspendExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Fragment>::Type>
+from_python<mx::Fragment>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDistributeDirective>>(gap::generator<mx::OMPDistributeDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPScopeDirective>::Type>
+from_python<mx::OMPScopeDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ConstantOp>(mx::ir::llvm::ConstantOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoUwtableAttrSpelling>::Type>
+from_python<mx::NoUwtableAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXScalarValueInitExpr>>(std::optional<mx::CXXScalarValueInitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ID>::Type>
+from_python<mx::ID>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ConstantOp>>(std::optional<mx::ir::llvm::ConstantOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RegexQuery>::Type>
+from_python<mx::RegexQuery>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CoroutineSuspendExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CoroutineSuspendExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Fragment>>::Type>
+from_python<std::optional<mx::Fragment>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElaboratedType>>(std::optional<mx::ElaboratedType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StandaloneDebugAttr>::Type>
+from_python<mx::StandaloneDebugAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IndirectGotoStmt>>(std::optional<mx::IndirectGotoStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPScanDirective>::Type>
+from_python<mx::OMPScanDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::DirectOp>(mx::ir::abi::DirectOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Compilation>::Type>
+from_python<mx::Compilation>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXScalarValueInitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXScalarValueInitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NonNullAttrSpelling>::Type>
+from_python<mx::NonNullAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DefaultStmt>>(std::optional<mx::DefaultStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IdentifierInfoFlag>::Type>
+from_python<mx::IdentifierInfoFlag>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::DirectOp>>(std::optional<mx::ir::abi::DirectOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NotTailCalledAttrSpelling>::Type>
+from_python<mx::NotTailCalledAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::IndirectGotoStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::IndirectGotoStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IfStatementKind>::Type>
+from_python<mx::IfStatementKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DefaultStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::DefaultStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SpeculativeLoadHardeningAttr>::Type>
+from_python<mx::SpeculativeLoadHardeningAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ExtractElementOp>(mx::ir::llvm::ExtractElementOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMasterDirective>::Type>
+from_python<mx::OMPParallelMasterDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ExtractElementOp>>(std::optional<mx::ir::llvm::ExtractElementOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPAllocateDeclAttrAllocatorTypeTy>::Type>
+from_python<mx::OMPAllocateDeclAttrAllocatorTypeTy>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDistributeDirective>>(std::optional<mx::OMPDistributeDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitParamKind>::Type>
+from_python<mx::ImplicitParamKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::FuncOp>(mx::ir::abi::FuncOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SharedTrylockFunctionAttr>::Type>
+from_python<mx::SharedTrylockFunctionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::EpilogueOp>(mx::ir::abi::EpilogueOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMaskedDirective>::Type>
+from_python<mx::OMPParallelMaskedDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDistributeDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDistributeDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareSimdDeclAttrBranchStateTy>::Type>
+from_python<mx::OMPDeclareSimdDeclAttrBranchStateTy>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::EpilogueOp>>(std::optional<mx::ir::abi::EpilogueOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InClassInitStyle>::Type>
+from_python<mx::InClassInitStyle>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FAddOp>(mx::ir::llvm::FAddOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SetTypestateAttr>::Type>
+from_python<mx::SetTypestateAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentTemplateSpecializationType>(mx::DependentTemplateSpecializationType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelDirective>::Type>
+from_python<mx::OMPParallelDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ExtractValueOp>(mx::ir::llvm::ExtractValueOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareTargetDeclAttrDevTypeTy>::Type>
+from_python<mx::OMPDeclareTargetDeclAttrDevTypeTy>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentTemplateSpecializationType>>(gap::generator<mx::DependentTemplateSpecializationType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InheritedDesignatedInitializersState>::Type>
+from_python<mx::InheritedDesignatedInitializersState>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ExtractValueOp>>(std::optional<mx::ir::llvm::ExtractValueOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareTargetDeclAttrMapTypeTy>::Type>
+from_python<mx::OMPDeclareTargetDeclAttrMapTypeTy>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::FuncOp>>(std::optional<mx::ir::abi::FuncOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InitStorageKind>::Type>
+from_python<mx::InitStorageKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentTemplateSpecializationType>>(std::optional<mx::DependentTemplateSpecializationType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SentinelAttr>::Type>
+from_python<mx::SentinelAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FCmpOp>(mx::ir::llvm::FCmpOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPOrderedDirective>::Type>
+from_python<mx::OMPOrderedDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpaqueValueExpr>(mx::OpaqueValueExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSConsumedAttrSpelling>::Type>
+from_python<mx::OSConsumedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FAddOp>>(std::optional<mx::ir::llvm::FAddOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InlineVariableDefinitionKind>::Type>
+from_python<mx::InlineVariableDefinitionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpaqueValueExpr>>(gap::generator<mx::OpaqueValueExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SelectAnyAttr>::Type>
+from_python<mx::SelectAnyAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXRewrittenBinaryOperator>(mx::CXXRewrittenBinaryOperator) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMetaDirective>::Type>
+from_python<mx::OMPMetaDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXParenListInitExpr>(mx::CXXParenListInitExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSConsumesThisAttrSpelling>::Type>
+from_python<mx::OSConsumesThisAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LabelDecl>(mx::LabelDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InterestingIdentifierKind>::Type>
+from_python<mx::InterestingIdentifierKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXRewrittenBinaryOperator>>(gap::generator<mx::CXXRewrittenBinaryOperator>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SectionAttr>::Type>
+from_python<mx::SectionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LabelDecl>>(std::optional<mx::LabelDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMasterDirective>::Type>
+from_python<mx::OMPMasterDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LabelDecl>>(gap::generator<mx::LabelDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsNotRetainedAttrSpelling>::Type>
+from_python<mx::OSReturnsNotRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CaseStmt>>(gap::generator<mx::CaseStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Kinds>::Type>
+from_python<mx::Kinds>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::IndirectOp>(mx::ir::abi::IndirectOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AArch64VectorPcsAttrSpelling>::Type>
+from_python<mx::AArch64VectorPcsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FDivOp>(mx::ir::llvm::FDivOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedAttrSpelling>::Type>
+from_python<mx::OSReturnsRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::IndirectOp>>(std::optional<mx::ir::abi::IndirectOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LambdaCaptureDefault>::Type>
+from_python<mx::LambdaCaptureDefault>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FCmpOp>>(std::optional<mx::ir::llvm::FCmpOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ScopedLockableAttr>::Type>
+from_python<mx::ScopedLockableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsGenericLoopDirective>(mx::OMPTeamsGenericLoopDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMaskedDirective>::Type>
+from_python<mx::OMPMaskedDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpaqueValueExpr>>(std::optional<mx::OpaqueValueExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedOnNonZeroAttrSpelling>::Type>
+from_python<mx::OSReturnsRetainedOnNonZeroAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentNameType>(mx::DependentNameType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LambdaCaptureKind>::Type>
+from_python<mx::LambdaCaptureKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDistributeParallelForSimdDirective>(mx::OMPTeamsDistributeParallelForSimdDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUFlatWorkGroupSizeAttrSpelling>::Type>
+from_python<mx::AMDGPUFlatWorkGroupSizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsGenericLoopDirective>>(gap::generator<mx::OMPTeamsGenericLoopDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLSpecialClassAttr>::Type>
+from_python<mx::SYCLSpecialClassAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentNameType>>(gap::generator<mx::DependentNameType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPLoopBasedDirective>::Type>
+from_python<mx::OMPLoopBasedDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXRewrittenBinaryOperator>>(std::optional<mx::CXXRewrittenBinaryOperator>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedOnZeroAttrSpelling>::Type>
+from_python<mx::OSReturnsRetainedOnZeroAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OpaqueValueExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::OpaqueValueExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LangAS>::Type>
+from_python<mx::LangAS>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::PrologueOp>(mx::ir::abi::PrologueOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AliasAttrSpelling>::Type>
+from_python<mx::AliasAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXRewrittenBinaryOperator, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXRewrittenBinaryOperator, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLKernelAttr>::Type>
+from_python<mx::SYCLKernelAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CaseStmt>>(std::optional<mx::CaseStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPLoopTransformationDirective>::Type>
+from_python<mx::OMPLoopTransformationDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::PrologueOp>>(std::optional<mx::ir::abi::PrologueOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBoxableAttrSpelling>::Type>
+from_python<mx::ObjCBoxableAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentNameType>>(std::optional<mx::DependentNameType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LangFeatures>::Type>
+from_python<mx::LangFeatures>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::LabelDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::LabelDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUNumSGPRAttrSpelling>::Type>
+from_python<mx::AMDGPUNumSGPRAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FMulOp>(mx::ir::llvm::FMulOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignedAttrSpelling>::Type>
+from_python<mx::AlignedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CaseStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::CaseStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeAttrSpelling>::Type>
+from_python<mx::ObjCBridgeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FDivOp>>(std::optional<mx::ir::llvm::FDivOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Language>::Type>
+from_python<mx::Language>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsGenericLoopDirective>>(std::optional<mx::OMPTeamsGenericLoopDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnsTwiceAttr>::Type>
+from_python<mx::ReturnsTwiceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::YieldOp>(mx::ir::abi::YieldOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPUnrollDirective>::Type>
+from_python<mx::OMPUnrollDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::abi::RetDirectOp>(mx::ir::abi::RetDirectOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeMutableAttrSpelling>::Type>
+from_python<mx::ObjCBridgeMutableAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTeamsGenericLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTeamsGenericLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LanguageLinkage>::Type>
+from_python<mx::LanguageLinkage>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::RetDirectOp>>(std::optional<mx::ir::abi::RetDirectOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnsNonNullAttr>::Type>
+from_python<mx::ReturnsNonNullAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FNegOp>(mx::ir::llvm::FNegOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTileDirective>::Type>
+from_python<mx::OMPTileDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VectorType>(mx::VectorType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUNumVGPRAttrSpelling>::Type>
+from_python<mx::AMDGPUNumVGPRAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UsingType>(mx::UsingType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>::Type>
+from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FMulOp>>(std::optional<mx::ir::llvm::FMulOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeRelatedAttrSpelling>::Type>
+from_python<mx::ObjCBridgeRelatedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VectorType>>(gap::generator<mx::VectorType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LaxVectorConversionKind>::Type>
+from_python<mx::LaxVectorConversionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::abi::YieldOp>>(std::optional<mx::ir::abi::YieldOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnTypestateAttr>::Type>
+from_python<mx::ReturnTypestateAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VectorType>>(std::optional<mx::VectorType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPLoopDirective>::Type>
+from_python<mx::OMPLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FPExtOp>(mx::ir::llvm::FPExtOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCClassStubAttrSpelling>::Type>
+from_python<mx::ObjCClassStubAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FNegOp>>(std::optional<mx::ir::llvm::FNegOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Level>::Type>
+from_python<mx::Level>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::Operation>(mx::ir::ll::Operation) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDesignatedInitializerAttrSpelling>::Type>
+from_python<mx::ObjCDesignatedInitializerAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::Operation>>(std::optional<mx::ir::ll::Operation>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Linkage>::Type>
+from_python<mx::Linkage>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LabelStmt>(mx::LabelStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RetainAttr>::Type>
+from_python<mx::RetainAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConvertVectorExpr>(mx::ConvertVectorExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPGenericLoopDirective>::Type>
+from_python<mx::OMPGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoawaitExpr>>(gap::generator<mx::CoawaitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDirectAttrSpelling>::Type>
+from_python<mx::ObjCDirectAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LabelStmt>>(gap::generator<mx::LabelStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LinkageSpecLanguageIDs>::Type>
+from_python<mx::LinkageSpecLanguageIDs>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::AllocaOp>(mx::ir::ll::AllocaOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RestrictAttr>::Type>
+from_python<mx::RestrictAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXPseudoDestructorExpr>(mx::CXXPseudoDestructorExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPForSimdDirective>::Type>
+from_python<mx::OMPForSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXNullPtrLiteralExpr>(mx::CXXNullPtrLiteralExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDirectMembersAttrSpelling>::Type>
+from_python<mx::ObjCDirectMembersAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AccessSpecDecl>(mx::AccessSpecDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSInheritanceModel>::Type>
+from_python<mx::MSInheritanceModel>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXPseudoDestructorExpr>>(gap::generator<mx::CXXPseudoDestructorExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RequiresCapabilityAttr>::Type>
+from_python<mx::RequiresCapabilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPThreadPrivateDecl>(mx::OMPThreadPrivateDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPForDirective>::Type>
+from_python<mx::OMPForDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AccessSpecDecl>>(gap::generator<mx::AccessSpecDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExceptionAttrSpelling>::Type>
+from_python<mx::ObjCExceptionAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::AllocaOp>>(std::optional<mx::ir::ll::AllocaOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSVCMajorVersion>::Type>
+from_python<mx::MSVCMajorVersion>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDistributeSimdDirective>(mx::OMPTeamsDistributeSimdDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExplicitProtocolImplAttrSpelling>::Type>
+from_python<mx::ObjCExplicitProtocolImplAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDistributeParallelForDirective>(mx::OMPTeamsDistributeParallelForDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSVtorDispMode>::Type>
+from_python<mx::MSVtorDispMode>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDistributeSimdDirective>>(gap::generator<mx::OMPTeamsDistributeSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReqdWorkGroupSizeAttr>::Type>
+from_python<mx::ReqdWorkGroupSizeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FPExtOp>>(std::optional<mx::ir::llvm::FPExtOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDistributeSimdDirective>::Type>
+from_python<mx::OMPDistributeSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExtVectorType>(mx::ExtVectorType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroVAOptArgument>::Type>
+from_python<mx::MacroVAOptArgument>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedUsingType>(mx::UnresolvedUsingType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroConcatenate>::Type>
+from_python<mx::MacroConcatenate>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExtVectorType>>(gap::generator<mx::ExtVectorType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroStringify>::Type>
+from_python<mx::MacroStringify>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoawaitExpr>>(std::optional<mx::CoawaitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroExpansion>::Type>
+from_python<mx::MacroExpansion>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::ArgAllocaOp>(mx::ir::ll::ArgAllocaOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Macro>::Type>
+from_python<mx::Macro>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LabelStmt>>(std::optional<mx::LabelStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroArgument>::Type>
+from_python<mx::MacroArgument>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::ArgAllocaOp>>(std::optional<mx::ir::ll::ArgAllocaOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroParameterSubstitution>::Type>
+from_python<mx::MacroParameterSubstitution>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CoawaitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CoawaitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroParameter>::Type>
+from_python<mx::MacroParameter>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXPseudoDestructorExpr>>(std::optional<mx::CXXPseudoDestructorExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaMacroDirective>::Type>
+from_python<mx::PragmaMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FPToUIOp>(mx::ir::llvm::FPToUIOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UndefineMacroDirective>::Type>
+from_python<mx::UndefineMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AccessSpecDecl>>(std::optional<mx::AccessSpecDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OtherMacroDirective>::Type>
+from_python<mx::OtherMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FPToSIOp>(mx::ir::llvm::FPToSIOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConditionalMacroDirective>::Type>
+from_python<mx::ConditionalMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::LabelStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::LabelStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EndIfMacroDirective>::Type>
+from_python<mx::EndIfMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExtVectorType>>(std::optional<mx::ExtVectorType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ElseMacroDirective>::Type>
+from_python<mx::ElseMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDistributeSimdDirective>>(std::optional<mx::OMPTeamsDistributeSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ElseIfNotDefinedMacroDirective>::Type>
+from_python<mx::ElseIfNotDefinedMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FPToSIOp>>(std::optional<mx::ir::llvm::FPToSIOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ElseIfDefinedMacroDirective>::Type>
+from_python<mx::ElseIfDefinedMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXPseudoDestructorExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXPseudoDestructorExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlwaysDestroyAttrSpelling>::Type>
+from_python<mx::AlwaysDestroyAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::AccessSpecDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::AccessSpecDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ElseIfMacroDirective>::Type>
+from_python<mx::ElseIfMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnaryOperator>>(gap::generator<mx::UnaryOperator>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IfNotDefinedMacroDirective>::Type>
+from_python<mx::IfNotDefinedMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCContainerDecl>>(gap::generator<mx::ObjCContainerDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlwaysInlineAttrSpelling>::Type>
+from_python<mx::AlwaysInlineAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlwaysDestroyAttr>>(std::optional<mx::AlwaysDestroyAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IfDefinedMacroDirective>::Type>
+from_python<mx::IfDefinedMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LoaderUninitializedAttr>>(std::optional<mx::LoaderUninitializedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnnotateAttrSpelling>::Type>
+from_python<mx::AnnotateAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSReturnsRetainedAttr>>(std::optional<mx::NSReturnsRetainedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnnotateTypeAttrSpelling>::Type>
+from_python<mx::AnnotateTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnaryOperator>>(std::optional<mx::UnaryOperator>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IfMacroDirective>::Type>
+from_python<mx::IfMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingPackDecl>>(gap::generator<mx::UsingPackDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86InterruptAttrSpelling>::Type>
+from_python<mx::AnyX86InterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCContainerDecl>>(std::optional<mx::ObjCContainerDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludeLikeMacroDirective>::Type>
+from_python<mx::IncludeLikeMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UnaryOperator, mx::ir::Operation>>>(gap::generator<std::pair<mx::UnaryOperator, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86NoCallerSavedRegistersAttrSpelling>::Type>
+from_python<mx::AnyX86NoCallerSavedRegistersAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCContainerDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCContainerDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ImportMacroDirective>::Type>
+from_python<mx::ImportMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AllocSizeAttr>>(gap::generator<mx::AllocSizeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86NoCfCheckAttrSpelling>::Type>
+from_python<mx::AnyX86NoCfCheckAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingPackDecl>>(std::optional<mx::UsingPackDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArcWeakrefUnavailableAttrSpelling>::Type>
+from_python<mx::ArcWeakrefUnavailableAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InitSegAttr>>(gap::generator<mx::InitSegAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<EntityId>::Type>
+from_python<EntityId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UsingPackDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::UsingPackDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludeMacrosMacroDirective>::Type>
+from_python<mx::IncludeMacrosMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSReturnsNotRetainedAttr>>(gap::generator<mx::NSReturnsNotRetainedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArgumentWithTypeTagAttrSpelling>::Type>
+from_python<mx::ArgumentWithTypeTagAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AllocSizeAttr>>(std::optional<mx::AllocSizeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludeNextMacroDirective>::Type>
+from_python<mx::IncludeNextMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InitSegAttr>>(std::optional<mx::InitSegAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmBuiltinAliasAttrSpelling>::Type>
+from_python<mx::ArmBuiltinAliasAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSReturnsNotRetainedAttr>>(std::optional<mx::NSReturnsNotRetainedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXCtorInitializer>::Type>
+from_python<mx::CXXCtorInitializer>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AllocAlignAttr>>(gap::generator<mx::AllocAlignAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenContext>::Type>
+from_python<mx::TokenContext>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodDecl>(mx::ObjCMethodDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludeMacroDirective>::Type>
+from_python<mx::IncludeMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCMethodDecl>>(std::optional<mx::ObjCMethodDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmMveStrictPolymorphismAttrSpelling>::Type>
+from_python<mx::ArmMveStrictPolymorphismAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCMethodDecl>>(gap::generator<mx::ObjCMethodDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArtificialAttrSpelling>::Type>
+from_python<mx::ArtificialAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnaryExprOrTypeTraitExpr>>(gap::generator<mx::UnaryExprOrTypeTraitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AsmLabelAttrSpelling>::Type>
+from_python<mx::AsmLabelAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IBOutletCollectionAttr>(mx::IBOutletCollectionAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AssertCapabilityAttrSpelling>::Type>
+from_python<mx::AssertCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IBOutletCollectionAttr>>(gap::generator<mx::IBOutletCollectionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AssumeAlignedAttrSpelling>::Type>
+from_python<mx::AssumeAlignedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSReturnsAutoreleasedAttr>>(gap::generator<mx::NSReturnsAutoreleasedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AssumptionAttrSpelling>::Type>
+from_python<mx::AssumptionAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AllocAlignAttr>>(std::optional<mx::AllocAlignAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::CXXCtorInitializer>>::Type>
+from_python<std::optional<mx::CXXCtorInitializer>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ClassTemplatePartialSpecializationDecl>(mx::ClassTemplatePartialSpecializationDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AtomicExprAtomicOp>::Type>
+from_python<mx::AtomicExprAtomicOp>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingDirectiveDecl>>(gap::generator<mx::UsingDirectiveDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailabilityAttrSpelling>::Type>
+from_python<mx::AvailabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCMethodDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCMethodDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailableOnlyInDefaultEvalMethodAttrSpelling>::Type>
+from_python<mx::AvailableOnlyInDefaultEvalMethodAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnaryExprOrTypeTraitExpr>>(std::optional<mx::UnaryExprOrTypeTraitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedStmtId>::Type>
+from_python<PackedStmtId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IBOutletCollectionAttr>>(std::optional<mx::IBOutletCollectionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BPFPreserveAccessIndexAttrSpelling>::Type>
+from_python<mx::BPFPreserveAccessIndexAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSReturnsAutoreleasedAttr>>(std::optional<mx::NSReturnsAutoreleasedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BPFPreserveStaticOffsetAttrSpelling>::Type>
+from_python<mx::BPFPreserveStaticOffsetAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UnaryExprOrTypeTraitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::UnaryExprOrTypeTraitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFDeclTagAttrSpelling>::Type>
+from_python<mx::BTFDeclTagAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AlignedAttr>(mx::AlignedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFTypeTagAttrSpelling>::Type>
+from_python<mx::BTFTypeTagAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingDirectiveDecl>>(std::optional<mx::UsingDirectiveDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BlocksAttrBlockType>::Type>
+from_python<mx::BlocksAttrBlockType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlignedAttr>>(gap::generator<mx::AlignedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BlocksAttrSpelling>::Type>
+from_python<mx::BlocksAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UsingDirectiveDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::UsingDirectiveDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinAliasAttrSpelling>::Type>
+from_python<mx::BuiltinAliasAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HotAttr>(mx::HotAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::filesystem::path>::Type>
+from_python<std::filesystem::path>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSErrorDomainAttr>(mx::NSErrorDomainAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinTypeKind>::Type>
+from_python<mx::BuiltinTypeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IBOutletAttr>>(gap::generator<mx::IBOutletAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CDeclAttrSpelling>::Type>
+from_python<mx::CDeclAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSErrorDomainAttr>>(gap::generator<mx::NSErrorDomainAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFAuditedTransferAttrSpelling>::Type>
+from_python<mx::CFAuditedTransferAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlignedAttr>>(std::optional<mx::AlignedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFConsumedAttrSpelling>::Type>
+from_python<mx::CFConsumedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyDecl>(mx::ObjCPropertyDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFGuardAttrGuardArg>::Type>
+from_python<mx::CFGuardAttrGuardArg>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IBOutletAttr>>(std::optional<mx::IBOutletAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedAttrId>::Type>
+from_python<PackedAttrId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSErrorDomainAttr>>(std::optional<mx::NSErrorDomainAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFGuardAttrSpelling>::Type>
+from_python<mx::CFGuardAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCPropertyDecl>>(gap::generator<mx::ObjCPropertyDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFICanonicalJumpTableAttrSpelling>::Type>
+from_python<mx::CFICanonicalJumpTableAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SubstNonTypeTemplateParmPackExpr>(mx::SubstNonTypeTemplateParmPackExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedMacroId>::Type>
+from_python<PackedMacroId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypoExpr>>(gap::generator<mx::TypoExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFReturnsNotRetainedAttrSpelling>::Type>
+from_python<mx::CFReturnsNotRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NamespaceDecl>(mx::NamespaceDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFReturnsRetainedAttrSpelling>::Type>
+from_python<mx::CFReturnsRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCPropertyDecl>>(std::optional<mx::ObjCPropertyDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFUnknownTransferAttrSpelling>::Type>
+from_python<mx::CFUnknownTransferAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AlignNaturalAttr>(mx::AlignNaturalAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::MacroKind>>::Type>
+from_python<std::span<const mx::MacroKind>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlignNaturalAttr>>(gap::generator<mx::AlignNaturalAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CPUDispatchAttrSpelling>::Type>
+from_python<mx::CPUDispatchAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NamespaceDecl>>(gap::generator<mx::NamespaceDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CPUSpecificAttrSpelling>::Type>
+from_python<mx::CPUSpecificAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IBActionAttr>(mx::IBActionAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::string_view>::Type>
+from_python<std::string_view>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSConsumesSelfAttr>(mx::NSConsumesSelfAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAConstantAttrSpelling>::Type>
+from_python<mx::CUDAConstantAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IBActionAttr>>(gap::generator<mx::IBActionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceAttrSpelling>::Type>
+from_python<mx::CUDADeviceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSConsumesSelfAttr>>(gap::generator<mx::NSConsumesSelfAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling>::Type>
+from_python<mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCPropertyDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCPropertyDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceBuiltinTextureTypeAttrSpelling>::Type>
+from_python<mx::CUDADeviceBuiltinTextureTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypoExpr>>(std::optional<mx::TypoExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAGlobalAttrSpelling>::Type>
+from_python<mx::CUDAGlobalAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TypoExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::TypoExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedTypeId>::Type>
+from_python<PackedTypeId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NamespaceDecl>>(std::optional<mx::NamespaceDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAHostAttrSpelling>::Type>
+from_python<mx::CUDAHostAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlignNaturalAttr>>(std::optional<mx::AlignNaturalAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDALaunchBoundsAttrSpelling>::Type>
+from_python<mx::CUDALaunchBoundsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IBActionAttr>>(std::optional<mx::IBActionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedTemplateArgumentId>::Type>
+from_python<PackedTemplateArgumentId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSConsumesSelfAttr>>(std::optional<mx::NSConsumesSelfAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDASharedAttrSpelling>::Type>
+from_python<mx::CUDASharedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::NamespaceDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::NamespaceDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXX11NoReturnAttrSpelling>::Type>
+from_python<mx::CXX11NoReturnAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AlignMac68kAttr>(mx::AlignMac68kAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedTemplateParameterListId>::Type>
+from_python<PackedTemplateParameterListId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AcquiredAfterAttr>(mx::AcquiredAfterAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXRecordDeclLambdaDependencyKind>::Type>
+from_python<mx::CXXRecordDeclLambdaDependencyKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlignMac68kAttr>>(gap::generator<mx::AlignMac68kAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CallExprADLCallKind>::Type>
+from_python<mx::CallExprADLCallKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MipsShortCallAttr>(mx::MipsShortCallAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CallableWhenAttrConsumedState>::Type>
+from_python<mx::CallableWhenAttrConsumedState>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLResourceBindingAttr>(mx::HLSLResourceBindingAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedCXXBaseSpecifierId>::Type>
+from_python<PackedCXXBaseSpecifierId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MipsInterruptAttr>(mx::MipsInterruptAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CallableWhenAttrSpelling>::Type>
+from_python<mx::CallableWhenAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HotAttr>>(gap::generator<mx::HotAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CallbackAttrSpelling>::Type>
+from_python<mx::CallbackAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MipsShortCallAttr>>(gap::generator<mx::MipsShortCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedDesignatorId>::Type>
+from_python<PackedDesignatorId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCIvarDecl>(mx::ObjCIvarDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CalledOnceAttrSpelling>::Type>
+from_python<mx::CalledOnceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeTraitExpr>(mx::TypeTraitExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CapabilityAttrSpelling>::Type>
+from_python<mx::CapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SubstNonTypeTemplateParmExpr>(mx::SubstNonTypeTemplateParmExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AVRSignalAttrSpelling>::Type>
+from_python<mx::AVRSignalAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIvarDecl>>(gap::generator<mx::ObjCIvarDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedCXXCtorInitializerId>::Type>
+from_python<PackedCXXCtorInitializerId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeTraitExpr>>(gap::generator<mx::TypeTraitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedStmtVariableCaptureKind>::Type>
+from_python<mx::CapturedStmtVariableCaptureKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlignMac68kAttr>>(std::optional<mx::AlignMac68kAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CarriesDependencyAttrSpelling>::Type>
+from_python<mx::CarriesDependencyAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HotAttr>>(std::optional<mx::HotAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AbiTagAttrSpelling>::Type>
+from_python<mx::AbiTagAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MipsShortCallAttr>>(std::optional<mx::MipsShortCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CleanupAttrSpelling>::Type>
+from_python<mx::CleanupAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIvarDecl>>(std::optional<mx::ObjCIvarDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeAlignAttrSpelling>::Type>
+from_python<mx::CodeAlignAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeTraitExpr>>(std::optional<mx::TypeTraitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeModelAttrSpelling>::Type>
+from_python<mx::CodeModelAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedUsingIfExistsDecl>(mx::UnresolvedUsingIfExistsDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ColdAttrSpelling>::Type>
+from_python<mx::ColdAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ClassTemplateSpecializationDecl>(mx::ClassTemplateSpecializationDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CommonAttrSpelling>::Type>
+from_python<mx::CommonAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedUsingIfExistsDecl>>(gap::generator<mx::UnresolvedUsingIfExistsDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstAttrSpelling>::Type>
+from_python<mx::ConstAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCIvarDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCIvarDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstInitAttrSpelling>::Type>
+from_python<mx::ConstInitAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TypeTraitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::TypeTraitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstructorAttrSpelling>::Type>
+from_python<mx::ConstructorAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AcquiredBeforeAttr>(mx::AcquiredBeforeAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAttrConsumedState>::Type>
+from_python<mx::ConsumableAttrConsumedState>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AcquireHandleAttr>(mx::AcquireHandleAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAttrSpelling>::Type>
+from_python<mx::ConsumableAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AcquiredBeforeAttr>>(gap::generator<mx::AcquiredBeforeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedFileId>::Type>
+from_python<PackedFileId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLShaderAttr>(mx::HLSLShaderAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAutoCastAttrSpelling>::Type>
+from_python<mx::ConsumableAutoCastAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLResourceAttr>(mx::HLSLResourceAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableSetOnReadAttrSpelling>::Type>
+from_python<mx::ConsumableSetOnReadAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MipsLongCallAttr>(mx::MipsLongCallAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConvergentAttrSpelling>::Type>
+from_python<mx::ConvergentAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLShaderAttr>>(gap::generator<mx::HLSLShaderAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroDisableLifetimeBoundAttrSpelling>::Type>
+from_python<mx::CoroDisableLifetimeBoundAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Mips16Attr>(mx::Mips16Attr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroLifetimeBoundAttrSpelling>::Type>
+from_python<mx::CoroLifetimeBoundAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MipsLongCallAttr>>(gap::generator<mx::MipsLongCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroOnlyDestroyWhenCompleteAttrSpelling>::Type>
+from_python<mx::CoroOnlyDestroyWhenCompleteAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedUsingIfExistsDecl>>(std::optional<mx::UnresolvedUsingIfExistsDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroReturnTypeAttrSpelling>::Type>
+from_python<mx::CoroReturnTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UnresolvedUsingIfExistsDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::UnresolvedUsingIfExistsDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroWrapperAttrSpelling>::Type>
+from_python<mx::CoroWrapperAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AcquiredBeforeAttr>>(std::optional<mx::AcquiredBeforeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CountedByAttrSpelling>::Type>
+from_python<mx::CountedByAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLShaderAttr>>(std::optional<mx::HLSLShaderAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedFragmentId>::Type>
+from_python<PackedFragmentId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DoOp>>(std::optional<mx::ir::hl::DoOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLExportAttrSpelling>::Type>
+from_python<mx::DLLExportAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TagType>>(std::optional<mx::TagType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLImportAttrSpelling>::Type>
+from_python<mx::DLLImportAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SAddSatOp>>(std::optional<mx::ir::llvm::SAddSatOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclFriendObjectKind>::Type>
+from_python<mx::DeclFriendObjectKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConditionalMacroDirective>>(std::optional<mx::ConditionalMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedCompilationId>::Type>
+from_python<PackedCompilationId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::EmptyDeclOp>(mx::ir::hl::EmptyDeclOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclIdentifierNamespace>::Type>
+from_python<mx::DeclIdentifierNamespace>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstructorAttr>>(gap::generator<mx::ConstructorAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclModuleOwnershipKind>::Type>
+from_python<mx::DeclModuleOwnershipKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SMaxOp>(mx::ir::llvm::SMaxOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclObjCDeclQualifier>::Type>
+from_python<mx::DeclObjCDeclQualifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::EmptyDeclOp>>(std::optional<mx::ir::hl::EmptyDeclOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeprecatedAttrSpelling>::Type>
+from_python<mx::DeprecatedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnaryTransformType>(mx::UnaryTransformType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<PackedDeclId>::Type>
+from_python<PackedDeclId>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SAddWithOverflowOp>(mx::ir::llvm::SAddWithOverflowOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DestructorAttrSpelling>::Type>
+from_python<mx::DestructorAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SysVABIAttr>>(gap::generator<mx::SysVABIAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnoseAsBuiltinAttrSpelling>::Type>
+from_python<mx::DiagnoseAsBuiltinAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingType>>(gap::generator<mx::UsingType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnoseIfAttrDiagnosticType>::Type>
+from_python<mx::DiagnoseIfAttrDiagnosticType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SAddWithOverflowOp>>(std::optional<mx::ir::llvm::SAddWithOverflowOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DisableSanitizerInstrumentationAttrSpelling>::Type>
+from_python<mx::DisableSanitizerInstrumentationAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::EnumConstantOp>(mx::ir::hl::EnumConstantOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DisableTailCallsAttrSpelling>::Type>
+from_python<mx::DisableTailCallsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::EnumConstantOp>>(std::optional<mx::ir::hl::EnumConstantOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnforceTCBAttrSpelling>::Type>
+from_python<mx::EnforceTCBAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RecordType>>(gap::generator<mx::RecordType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnforceTCBLeafAttrSpelling>::Type>
+from_python<mx::EnforceTCBLeafAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingType>>(std::optional<mx::UsingType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumExtensibilityAttrKind>::Type>
+from_python<mx::EnumExtensibilityAttrKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SMinOp>(mx::ir::llvm::SMinOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumExtensibilityAttrSpelling>::Type>
+from_python<mx::EnumExtensibilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstructorAttr>>(std::optional<mx::ConstructorAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ErrorAttrSpelling>::Type>
+from_python<mx::ErrorAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EndIfMacroDirective>>(gap::generator<mx::EndIfMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReleaseCapabilityAttr>::Type>
+from_python<mx::ReleaseCapabilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SMaxOp>>(std::optional<mx::ir::llvm::SMaxOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CStyleCastExpr>::Type>
+from_python<mx::CStyleCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SysVABIAttr>>(std::optional<mx::SysVABIAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReinitializesAttr>::Type>
+from_python<mx::ReinitializesAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::EnumDeclOp>(mx::ir::hl::EnumDeclOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinBitCastExpr>::Type>
+from_python<mx::BuiltinBitCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RecordType>>(std::optional<mx::RecordType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RegCallAttr>::Type>
+from_python<mx::RegCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::EnumDeclOp>>(std::optional<mx::ir::hl::EnumDeclOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgedCastExpr>::Type>
+from_python<mx::ObjCBridgedCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UsingShadowDecl>(mx::UsingShadowDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReadOnlyPlacementAttr>::Type>
+from_python<mx::ReadOnlyPlacementAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SMinOp>>(std::optional<mx::ir::llvm::SMinOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CallExpr>::Type>
+from_python<mx::CallExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::Type>>(std::optional<mx::ir::Type>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RandomizeLayoutAttr>::Type>
+from_python<mx::RandomizeLayoutAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingShadowDecl>>(gap::generator<mx::UsingShadowDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXOperatorCallExpr>::Type>
+from_python<mx::CXXOperatorCallExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstInitAttr>>(gap::generator<mx::ConstInitAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RISCVInterruptAttr>::Type>
+from_python<mx::RISCVInterruptAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ExprOp>(mx::ir::hl::ExprOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXMemberCallExpr>::Type>
+from_python<mx::CXXMemberCallExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::EnumRefOp>(mx::ir::hl::EnumRefOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PureAttr>::Type>
+from_python<mx::PureAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EndIfMacroDirective>>(std::optional<mx::EndIfMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAKernelCallExpr>::Type>
+from_python<mx::CUDAKernelCallExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftPrivateAttr>>(gap::generator<mx::SwiftPrivateAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PtGuardedVarAttr>::Type>
+from_python<mx::PtGuardedVarAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::EnumRefOp>>(std::optional<mx::ir::hl::EnumRefOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UserDefinedLiteral>::Type>
+from_python<mx::UserDefinedLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SMulWithOverflowOp>(mx::ir::llvm::SMulWithOverflowOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PtGuardedByAttr>::Type>
+from_python<mx::PtGuardedByAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SMulWithOverflowOp>>(std::optional<mx::ir::llvm::SMulWithOverflowOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXUuidofExpr>::Type>
+from_python<mx::CXXUuidofExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnumType>>(gap::generator<mx::EnumType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PreserveMostAttr>::Type>
+from_python<mx::PreserveMostAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingShadowDecl>>(std::optional<mx::UsingShadowDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXUnresolvedConstructExpr>::Type>
+from_python<mx::CXXUnresolvedConstructExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstInitAttr>>(std::optional<mx::ConstInitAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PreserveAllAttr>::Type>
+from_python<mx::PreserveAllAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SSACopyOp>(mx::ir::llvm::SSACopyOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXTypeidExpr>::Type>
+from_python<mx::CXXTypeidExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnumType>>(std::optional<mx::EnumType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PreferredTypeAttr>::Type>
+from_python<mx::PreferredTypeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UsingShadowDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::UsingShadowDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXThrowExpr>::Type>
+from_python<mx::CXXThrowExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ExprOp>>(std::optional<mx::ir::hl::ExprOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PreferredNameAttr>::Type>
+from_python<mx::PreferredNameAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftPrivateAttr>>(std::optional<mx::SwiftPrivateAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNewExpr>::Type>
+from_python<mx::CXXNewExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SSACopyOp>>(std::optional<mx::ir::llvm::SSACopyOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangTextSectionAttr>::Type>
+from_python<mx::PragmaClangTextSectionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ElseMacroDirective>(mx::ElseMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXThisExpr>::Type>
+from_python<mx::CXXThisExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElseMacroDirective>>(gap::generator<mx::ElseMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangRodataSectionAttr>::Type>
+from_python<mx::PragmaClangRodataSectionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::FCmpOp>(mx::ir::hl::FCmpOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXStdInitializerListExpr>::Type>
+from_python<mx::CXXStdInitializerListExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ExtensionOp>(mx::ir::hl::ExtensionOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangRelroSectionAttr>::Type>
+from_python<mx::PragmaClangRelroSectionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ExtensionOp>>(std::optional<mx::ir::hl::ExtensionOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXScalarValueInitExpr>::Type>
+from_python<mx::CXXScalarValueInitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SShlSatOp>(mx::ir::llvm::SShlSatOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangDataSectionAttr>::Type>
+from_python<mx::PragmaClangDataSectionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SShlSatOp>>(std::optional<mx::ir::llvm::SShlSatOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXRewrittenBinaryOperator>::Type>
+from_python<mx::CXXRewrittenBinaryOperator>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstAttr>(mx::ConstAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaClangBSSSectionAttr>::Type>
+from_python<mx::PragmaClangBSSSectionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstAttr>>(gap::generator<mx::ConstAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXPseudoDestructorExpr>::Type>
+from_python<mx::CXXPseudoDestructorExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SubstTemplateTypeParmType>(mx::SubstTemplateTypeParmType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PointerAttr>::Type>
+from_python<mx::PointerAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftNewTypeAttr>(mx::SwiftNewTypeAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXParenListInitExpr>::Type>
+from_python<mx::CXXParenListInitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SubstTemplateTypeParmType>>(gap::generator<mx::SubstTemplateTypeParmType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PcsAttr>::Type>
+from_python<mx::PcsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftNewTypeAttr>>(gap::generator<mx::SwiftNewTypeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNullPtrLiteralExpr>::Type>
+from_python<mx::CXXNullPtrLiteralExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElseMacroDirective>>(std::optional<mx::ElseMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PatchableFunctionEntryAttr>::Type>
+from_python<mx::PatchableFunctionEntryAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SSubSatOp>(mx::ir::llvm::SSubSatOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNoexceptExpr>::Type>
+from_python<mx::CXXNoexceptExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::FCmpOp>>(std::optional<mx::ir::hl::FCmpOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PascalAttr>::Type>
+from_python<mx::PascalAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SSubSatOp>>(std::optional<mx::ir::llvm::SSubSatOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConstructExpr>::Type>
+from_python<mx::CXXConstructExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstTemplateTypeParmType>>(std::optional<mx::SubstTemplateTypeParmType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParamTypestateAttr>::Type>
+from_python<mx::ParamTypestateAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstAttr>>(std::optional<mx::ConstAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXInheritedCtorInitExpr>::Type>
+from_python<mx::CXXInheritedCtorInitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftNewTypeAttr>>(std::optional<mx::SwiftNewTypeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PackedAttr>::Type>
+from_python<mx::PackedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SinOp>(mx::ir::llvm::SinOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXFoldExpr>::Type>
+from_python<mx::CXXFoldExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BaseUsingDecl>(mx::BaseUsingDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OwnershipAttr>::Type>
+from_python<mx::OwnershipAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SSubWithOverflowOp>(mx::ir::llvm::SSubWithOverflowOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDependentScopeMemberExpr>::Type>
+from_python<mx::CXXDependentScopeMemberExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::FieldDeclOp>(mx::ir::hl::FieldDeclOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OwnerAttr>::Type>
+from_python<mx::OwnerAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SSubWithOverflowOp>>(std::optional<mx::ir::llvm::SSubWithOverflowOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDeleteExpr>::Type>
+from_python<mx::CXXDeleteExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BaseUsingDecl>>(gap::generator<mx::BaseUsingDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OverrideAttr>::Type>
+from_python<mx::OverrideAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::FieldDeclOp>>(std::optional<mx::ir::hl::FieldDeclOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDefaultInitExpr>::Type>
+from_python<mx::CXXDefaultInitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ElseIfNotDefinedMacroDirective>(mx::ElseIfNotDefinedMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OptimizeNoneAttr>::Type>
+from_python<mx::OptimizeNoneAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElseIfNotDefinedMacroDirective>>(gap::generator<mx::ElseIfNotDefinedMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDefaultArgExpr>::Type>
+from_python<mx::CXXDefaultArgExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SqrtOp>(mx::ir::llvm::SqrtOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLKernelAttr>::Type>
+from_python<mx::OpenCLKernelAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SinOp>>(std::optional<mx::ir::llvm::SinOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXTemporaryObjectExpr>::Type>
+from_python<mx::CXXTemporaryObjectExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CommonAttr>(mx::CommonAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLIntelReqdSubGroupSizeAttr>::Type>
+from_python<mx::OpenCLIntelReqdSubGroupSizeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ForOp>(mx::ir::hl::ForOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXBoolLiteralExpr>::Type>
+from_python<mx::CXXBoolLiteralExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CommonAttr>>(gap::generator<mx::CommonAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSubclassingRestrictedAttr>::Type>
+from_python<mx::ObjCSubclassingRestrictedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SubstTemplateTypeParmPackType>(mx::SubstTemplateTypeParmPackType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXBindTemporaryExpr>::Type>
+from_python<mx::CXXBindTemporaryExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::FileScopeAsmOp>(mx::ir::hl::FileScopeAsmOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRootClassAttr>::Type>
+from_python<mx::ObjCRootClassAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SubstTemplateTypeParmPackType>>(gap::generator<mx::SubstTemplateTypeParmPackType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BlockExpr>::Type>
+from_python<mx::BlockExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BaseUsingDecl>>(std::optional<mx::BaseUsingDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCReturnsInnerPointerAttr>::Type>
+from_python<mx::ObjCReturnsInnerPointerAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftNameAttr>(mx::SwiftNameAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BlockDecl>::Type>
+from_python<mx::BlockDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::FileScopeAsmOp>>(std::optional<mx::ir::hl::FileScopeAsmOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRequiresSuperAttr>::Type>
+from_python<mx::ObjCRequiresSuperAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftNameAttr>>(gap::generator<mx::SwiftNameAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BinaryOperator>::Type>
+from_python<mx::BinaryOperator>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::BaseUsingDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::BaseUsingDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRequiresPropertyDefsAttr>::Type>
+from_python<mx::ObjCRequiresPropertyDefsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::FuncOp>(mx::ir::hl::FuncOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CompoundAssignOperator>::Type>
+from_python<mx::CompoundAssignOperator>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstTemplateTypeParmPackType>>(std::optional<mx::SubstTemplateTypeParmPackType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPreciseLifetimeAttr>::Type>
+from_python<mx::ObjCPreciseLifetimeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElseIfNotDefinedMacroDirective>>(std::optional<mx::ElseIfNotDefinedMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AtomicExpr>::Type>
+from_python<mx::AtomicExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SqrtOp>>(std::optional<mx::ir::llvm::SqrtOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCOwnershipAttr>::Type>
+from_python<mx::ObjCOwnershipAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ForOp>>(std::optional<mx::ir::hl::ForOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AsTypeExpr>::Type>
+from_python<mx::AsTypeExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CommonAttr>>(std::optional<mx::CommonAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNSObjectAttr>::Type>
+from_python<mx::ObjCNSObjectAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftNameAttr>>(std::optional<mx::SwiftNameAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayTypeTraitExpr>::Type>
+from_python<mx::ArrayTypeTraitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::StackRestoreOp>(mx::ir::llvm::StackRestoreOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodFamilyAttr>::Type>
+from_python<mx::ObjCMethodFamilyAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::FuncOp>>(std::optional<mx::ir::hl::FuncOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArraySubscriptExpr>::Type>
+from_python<mx::ArraySubscriptExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::StackRestoreOp>>(std::optional<mx::ir::llvm::StackRestoreOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIndependentClassAttr>::Type>
+from_python<mx::ObjCIndependentClassAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ElseIfDefinedMacroDirective>(mx::ElseIfDefinedMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayInitLoopExpr>::Type>
+from_python<mx::ArrayInitLoopExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::StackSaveOp>(mx::ir::llvm::StackSaveOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExternallyRetainedAttr>::Type>
+from_python<mx::ObjCExternallyRetainedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElseIfDefinedMacroDirective>>(gap::generator<mx::ElseIfDefinedMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayInitIndexExpr>::Type>
+from_python<mx::ArrayInitIndexExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ColdAttr>(mx::ColdAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExplicitProtocolImplAttr>::Type>
+from_python<mx::ObjCExplicitProtocolImplAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::StackSaveOp>>(std::optional<mx::ir::llvm::StackSaveOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AbstractConditionalOperator>::Type>
+from_python<mx::AbstractConditionalOperator>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CodeModelAttr>(mx::CodeModelAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExceptionAttr>::Type>
+from_python<mx::ObjCExceptionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ColdAttr>>(gap::generator<mx::ColdAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConditionalOperator>::Type>
+from_python<mx::ConditionalOperator>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReferenceType>(mx::ReferenceType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeRelatedAttr>::Type>
+from_python<mx::ObjCBridgeRelatedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReferenceType>>(gap::generator<mx::ReferenceType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BinaryConditionalOperator>::Type>
+from_python<mx::BinaryConditionalOperator>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftImportPropertyAsAccessorsAttr>(mx::SwiftImportPropertyAsAccessorsAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeMutableAttr>::Type>
+from_python<mx::ObjCBridgeMutableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::FuncRefOp>(mx::ir::hl::FuncRefOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VAArgExpr>::Type>
+from_python<mx::VAArgExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftErrorAttr>(mx::SwiftErrorAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AllocAlignAttrSpelling>::Type>
+from_python<mx::AllocAlignAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftImportPropertyAsAccessorsAttr>>(gap::generator<mx::SwiftImportPropertyAsAccessorsAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeAttr>::Type>
+from_python<mx::ObjCBridgeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::FuncRefOp>>(std::optional<mx::ir::hl::FuncRefOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryOperator>::Type>
+from_python<mx::UnaryOperator>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::StepVectorOp>(mx::ir::llvm::StepVectorOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedOnZeroAttr>::Type>
+from_python<mx::OSReturnsRetainedOnZeroAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReferenceType>>(std::optional<mx::ReferenceType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryExprOrTypeTraitExpr>::Type>
+from_python<mx::UnaryExprOrTypeTraitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::StepVectorOp>>(std::optional<mx::ir::llvm::StepVectorOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedOnNonZeroAttr>::Type>
+from_python<mx::OSReturnsRetainedOnNonZeroAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ColdAttr>>(std::optional<mx::ColdAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypoExpr>::Type>
+from_python<mx::TypoExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypedefType>(mx::TypedefType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsRetainedAttr>::Type>
+from_python<mx::OSReturnsRetainedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElseIfDefinedMacroDirective>>(std::optional<mx::ElseIfDefinedMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeTraitExpr>::Type>
+from_python<mx::TypeTraitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedUsingType>>(gap::generator<mx::UnresolvedUsingType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSReturnsNotRetainedAttr>::Type>
+from_python<mx::OSReturnsNotRetainedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::GenericAssocExprOp>(mx::ir::hl::GenericAssocExprOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstNonTypeTemplateParmPackExpr>::Type>
+from_python<mx::SubstNonTypeTemplateParmPackExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::TrapOp>(mx::ir::llvm::TrapOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSConsumesThisAttr>::Type>
+from_python<mx::OSConsumesThisAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ThreadLocalAddressOp>(mx::ir::llvm::ThreadLocalAddressOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NonTypeTemplateParmDecl>::Type>
+from_python<mx::NonTypeTemplateParmDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::GenericAssocExprOp>>(std::optional<mx::ir::hl::GenericAssocExprOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPThreadPrivateDeclAttr>::Type>
+from_python<mx::OMPThreadPrivateDeclAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftImportPropertyAsAccessorsAttr>>(std::optional<mx::SwiftImportPropertyAsAccessorsAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstNonTypeTemplateParmExpr>::Type>
+from_python<mx::SubstNonTypeTemplateParmExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ThreadLocalAddressOp>>(std::optional<mx::ir::llvm::ThreadLocalAddressOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareVariantAttr>::Type>
+from_python<mx::OMPDeclareVariantAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedUsingType>>(std::optional<mx::UnresolvedUsingType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StmtExpr>::Type>
+from_python<mx::StmtExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RValueReferenceType>(mx::RValueReferenceType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareTargetDeclAttr>::Type>
+from_python<mx::OMPDeclareTargetDeclAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::GenericSelectionExprOp>(mx::ir::hl::GenericSelectionExprOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SourceLocExpr>::Type>
+from_python<mx::SourceLocExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::QualifiedType>(mx::QualifiedType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCaptureNoInitAttr>::Type>
+from_python<mx::OMPCaptureNoInitAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RValueReferenceType>>(gap::generator<mx::RValueReferenceType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SizeOfPackExpr>::Type>
+from_python<mx::SizeOfPackExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CodeSegAttr>(mx::CodeSegAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPAllocateDeclAttr>::Type>
+from_python<mx::OMPAllocateDeclAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::GenericSelectionExprOp>>(std::optional<mx::ir::hl::GenericSelectionExprOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ShuffleVectorExpr>::Type>
+from_python<mx::ShuffleVectorExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CmseNSEntryAttr>(mx::CmseNSEntryAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NotTailCalledAttr>::Type>
+from_python<mx::NotTailCalledAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::TrapOp>>(std::optional<mx::ir::llvm::TrapOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLUniqueStableNameExpr>::Type>
+from_python<mx::SYCLUniqueStableNameExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CodeSegAttr>>(gap::generator<mx::CodeSegAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoUwtableAttr>::Type>
+from_python<mx::NoUwtableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ElseIfMacroDirective>(mx::ElseIfMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RequiresExpr>::Type>
+from_python<mx::RequiresExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IfNotDefinedMacroDirective>(mx::IfNotDefinedMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoUniqueAddressAttr>::Type>
+from_python<mx::NoUniqueAddressAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElseIfMacroDirective>>(gap::generator<mx::ElseIfMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RequiresExprBodyDecl>::Type>
+from_python<mx::RequiresExprBodyDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftImportAsNonGenericAttr>(mx::SwiftImportAsNonGenericAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoThrowAttr>::Type>
+from_python<mx::NoThrowAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftCallAttr>(mx::SwiftCallAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RecoveryExpr>::Type>
+from_python<mx::RecoveryExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UAddSatOp>(mx::ir::llvm::UAddSatOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoThreadSafetyAnalysisAttr>::Type>
+from_python<mx::NoThreadSafetyAnalysisAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftImportAsNonGenericAttr>>(gap::generator<mx::SwiftImportAsNonGenericAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PseudoObjectExpr>::Type>
+from_python<mx::PseudoObjectExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RValueReferenceType>>(std::optional<mx::RValueReferenceType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoStackProtectorAttr>::Type>
+from_python<mx::NoStackProtectorAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UAddSatOp>>(std::optional<mx::ir::llvm::UAddSatOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PredefinedExpr>::Type>
+from_python<mx::PredefinedExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedUsingTypenameDecl>(mx::UnresolvedUsingTypenameDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSplitStackAttr>::Type>
+from_python<mx::NoSplitStackAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedUsingTypenameDecl>>(gap::generator<mx::UnresolvedUsingTypenameDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParenListExpr>::Type>
+from_python<mx::ParenListExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::GlobalRefOp>(mx::ir::hl::GlobalRefOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSpeculativeLoadHardeningAttr>::Type>
+from_python<mx::NoSpeculativeLoadHardeningAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CodeSegAttr>>(std::optional<mx::CodeSegAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParenExpr>::Type>
+from_python<mx::ParenExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::GlobalRefOp>>(std::optional<mx::ir::hl::GlobalRefOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoSanitizeAttr>::Type>
+from_python<mx::NoSanitizeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UAddWithOverflowOp>(mx::ir::llvm::UAddWithOverflowOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PackExpansionExpr>::Type>
+from_python<mx::PackExpansionExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UAddWithOverflowOp>>(std::optional<mx::ir::llvm::UAddWithOverflowOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoReturnAttr>::Type>
+from_python<mx::NoReturnAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftImportAsNonGenericAttr>>(std::optional<mx::SwiftImportAsNonGenericAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedMemberExpr>::Type>
+from_python<mx::UnresolvedMemberExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElseIfMacroDirective>>(std::optional<mx::ElseIfMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoRandomizeLayoutAttr>::Type>
+from_python<mx::NoRandomizeLayoutAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LValueReferenceType>(mx::LValueReferenceType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OffsetOfExpr>::Type>
+from_python<mx::OffsetOfExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PointerType>(mx::PointerType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoProfileFunctionAttr>::Type>
+from_python<mx::NoProfileFunctionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedUsingTypenameDecl>>(std::optional<mx::UnresolvedUsingTypenameDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSubscriptRefExpr>::Type>
+from_python<mx::ObjCSubscriptRefExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::GotoStmtOp>(mx::ir::hl::GotoStmtOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMips16Attr>::Type>
+from_python<mx::NoMips16Attr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LValueReferenceType>>(gap::generator<mx::LValueReferenceType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCStringLiteral>::Type>
+from_python<mx::ObjCStringLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UMaxOp>(mx::ir::llvm::UMaxOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMicroMipsAttr>::Type>
+from_python<mx::NoMicroMipsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::GotoStmtOp>>(std::optional<mx::ir::hl::GotoStmtOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSelectorExpr>::Type>
+from_python<mx::ObjCSelectorExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UBSanTrapOp>(mx::ir::llvm::UBSanTrapOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInstrumentFunctionAttr>::Type>
+from_python<mx::NoInstrumentFunctionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UnresolvedUsingTypenameDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::UnresolvedUsingTypenameDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCProtocolExpr>::Type>
+from_python<mx::ObjCProtocolExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UBSanTrapOp>>(std::optional<mx::ir::llvm::UBSanTrapOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDuplicateAttr>::Type>
+from_python<mx::NoDuplicateAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::BrOp>(mx::ir::ll::BrOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMessageExpr>::Type>
+from_python<mx::ObjCMessageExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::BrOp>>(std::optional<mx::ir::ll::BrOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDestroyAttr>::Type>
+from_python<mx::NoDestroyAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PascalAttr>>(gap::generator<mx::PascalAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIvarRefExpr>::Type>
+from_python<mx::ObjCIvarRefExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBoolLiteralExpr>>(std::optional<mx::ObjCBoolLiteralExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDebugAttr>::Type>
+from_python<mx::NoDebugAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoDerefAttr>>(gap::generator<mx::NoDerefAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIsaExpr>::Type>
+from_python<mx::ObjCIsaExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::ConcatOp>(mx::ir::ll::ConcatOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoCommonAttr>::Type>
+from_python<mx::NoCommonAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCBoolLiteralExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCBoolLiteralExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIndirectCopyRestoreExpr>::Type>
+from_python<mx::ObjCIndirectCopyRestoreExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::ConcatOp>>(std::optional<mx::ir::ll::ConcatOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoAliasAttr>::Type>
+from_python<mx::NoAliasAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLResourceBindingAttr>>(gap::generator<mx::HLSLResourceBindingAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCEncodeExpr>::Type>
+from_python<mx::ObjCEncodeExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PascalAttr>>(std::optional<mx::PascalAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NakedAttr>::Type>
+from_python<mx::NakedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::CondBrOp>(mx::ir::ll::CondBrOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDictionaryLiteral>::Type>
+from_python<mx::ObjCDictionaryLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoDerefAttr>>(std::optional<mx::NoDerefAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NVPTXKernelAttr>::Type>
+from_python<mx::NVPTXKernelAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::CondBrOp>>(std::optional<mx::ir::ll::CondBrOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBoxedExpr>::Type>
+from_python<mx::ObjCBoxedExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoyieldExpr>>(gap::generator<mx::CoyieldExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsRetainedAttr>::Type>
+from_python<mx::NSReturnsRetainedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLResourceBindingAttr>>(std::optional<mx::HLSLResourceBindingAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBoolLiteralExpr>::Type>
+from_python<mx::ObjCBoolLiteralExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::CondScopeRetOp>(mx::ir::ll::CondScopeRetOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsNotRetainedAttr>::Type>
+from_python<mx::NSReturnsNotRetainedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::CondScopeRetOp>>(std::optional<mx::ir::ll::CondScopeRetOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAvailabilityCheckExpr>::Type>
+from_python<mx::ObjCAvailabilityCheckExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParamTypestateAttr>>(gap::generator<mx::ParamTypestateAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSReturnsAutoreleasedAttr>::Type>
+from_python<mx::NSReturnsAutoreleasedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXConstructorDecl>>(std::optional<mx::CXXConstructorDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCArrayLiteral>::Type>
+from_python<mx::ObjCArrayLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoyieldExpr>>(std::optional<mx::CoyieldExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSErrorDomainAttr>::Type>
+from_python<mx::NSErrorDomainAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLParamModifierAttr>>(gap::generator<mx::HLSLParamModifierAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPIteratorExpr>::Type>
+from_python<mx::OMPIteratorExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::ExtractOp>(mx::ir::ll::ExtractOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSConsumesSelfAttr>::Type>
+from_python<mx::NSConsumesSelfAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXConstructorDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXConstructorDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPArrayShapingExpr>::Type>
+from_python<mx::OMPArrayShapingExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CoyieldExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CoyieldExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsShortCallAttr>::Type>
+from_python<mx::MipsShortCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::ExtractOp>>(std::optional<mx::ir::ll::ExtractOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPArraySectionExpr>::Type>
+from_python<mx::OMPArraySectionExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAvailabilityCheckExpr>>(gap::generator<mx::ObjCAvailabilityCheckExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsLongCallAttr>::Type>
+from_python<mx::MipsLongCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParamTypestateAttr>>(std::optional<mx::ParamTypestateAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInitExpr>::Type>
+from_python<mx::NoInitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLResourceAttr>>(gap::generator<mx::HLSLResourceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCExternallyRetainedAttrSpelling>::Type>
+from_python<mx::ObjCExternallyRetainedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLParamModifierAttr>>(std::optional<mx::HLSLParamModifierAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDistributeParallelForSimdDirective>::Type>
+from_python<mx::OMPDistributeParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::InitializeVarOp>(mx::ir::ll::InitializeVarOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCGCAttrSpelling>::Type>
+from_python<mx::ObjCGCAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::InitializeVarOp>>(std::optional<mx::ir::ll::InitializeVarOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDistributeParallelForDirective>::Type>
+from_python<mx::OMPDistributeParallelForDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAvailabilityCheckExpr>>(std::optional<mx::ObjCAvailabilityCheckExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIndependentClassAttrSpelling>::Type>
+from_python<mx::ObjCIndependentClassAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCAvailabilityCheckExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCAvailabilityCheckExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDistributeDirective>::Type>
+from_python<mx::OMPDistributeDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLResourceAttr>>(std::optional<mx::HLSLResourceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIvarDeclAccessControl>::Type>
+from_python<mx::ObjCIvarDeclAccessControl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::LoadOp>(mx::ir::ll::LoadOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMessageExprReceiverKind>::Type>
+from_python<mx::ObjCMessageExprReceiverKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PackedAttr>(mx::PackedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsGenericLoopDirective>::Type>
+from_python<mx::OMPTeamsGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::InlineScopeOp>(mx::ir::ll::InlineScopeOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodFamilyAttrFamilyKind>::Type>
+from_python<mx::ObjCMethodFamilyAttrFamilyKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PackedAttr>>(gap::generator<mx::PackedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDistributeSimdDirective>::Type>
+from_python<mx::OMPTeamsDistributeSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::InlineScopeOp>>(std::optional<mx::ir::ll::InlineScopeOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodFamilyAttrSpelling>::Type>
+from_python<mx::ObjCMethodFamilyAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLGroupSharedAddressSpaceAttr>(mx::HLSLGroupSharedAddressSpaceAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDistributeParallelForSimdDirective>::Type>
+from_python<mx::OMPTeamsDistributeParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CompoundLiteralExpr>(mx::CompoundLiteralExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNSObjectAttrSpelling>::Type>
+from_python<mx::ObjCNSObjectAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConvertVectorExpr>>(gap::generator<mx::ConvertVectorExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNonLazyClassAttrSpelling>::Type>
+from_python<mx::ObjCNonLazyClassAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::FuncOp>(mx::ir::ll::FuncOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDistributeParallelForDirective>::Type>
+from_python<mx::OMPTeamsDistributeParallelForDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLGroupSharedAddressSpaceAttr>>(gap::generator<mx::HLSLGroupSharedAddressSpaceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNonRuntimeProtocolAttrSpelling>::Type>
+from_python<mx::ObjCNonRuntimeProtocolAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::LoadOp>>(std::optional<mx::ir::ll::LoadOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTeamsDistributeDirective>::Type>
+from_python<mx::OMPTeamsDistributeDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PackedAttr>>(std::optional<mx::PackedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCOwnershipAttrSpelling>::Type>
+from_python<mx::ObjCOwnershipAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FriendDecl>(mx::FriendDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskLoopSimdDirective>::Type>
+from_python<mx::OMPTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLNumThreadsAttr>(mx::HLSLNumThreadsAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPreciseLifetimeAttrSpelling>::Type>
+from_python<mx::ObjCPreciseLifetimeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<std::vector<mx::FriendDecl>>>(std::optional<std::vector<mx::FriendDecl>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyDeclPropertyControl>::Type>
+from_python<mx::ObjCPropertyDeclPropertyControl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLNumThreadsAttr>>(gap::generator<mx::HLSLNumThreadsAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTaskLoopDirective>::Type>
+from_python<mx::OMPTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FriendDecl>>(gap::generator<mx::FriendDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyDeclSetterKind>::Type>
+from_python<mx::ObjCPropertyDeclSetterKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConvertVectorExpr>>(std::optional<mx::ConvertVectorExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsGenericLoopDirective>::Type>
+from_python<mx::OMPTargetTeamsGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::FuncOp>>(std::optional<mx::ir::ll::FuncOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyImplDeclKind>::Type>
+from_python<mx::ObjCPropertyImplDeclKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLGroupSharedAddressSpaceAttr>>(std::optional<mx::HLSLGroupSharedAddressSpaceAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDistributeSimdDirective>::Type>
+from_python<mx::OMPTargetTeamsDistributeSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ConvertVectorExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ConvertVectorExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRequiresPropertyDefsAttrSpelling>::Type>
+from_python<mx::ObjCRequiresPropertyDefsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OwnershipAttr>(mx::OwnershipAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRequiresSuperAttrSpelling>::Type>
+from_python<mx::ObjCRequiresSuperAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPArrayShapingExpr>(mx::OMPArrayShapingExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDistributeParallelForSimdDirective>::Type>
+from_python<mx::OMPTargetTeamsDistributeParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLNumThreadsAttr>>(std::optional<mx::HLSLNumThreadsAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCReturnsInnerPointerAttrSpelling>::Type>
+from_python<mx::ObjCReturnsInnerPointerAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OwnershipAttr>>(gap::generator<mx::OwnershipAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMasterTaskLoopDirective>::Type>
+from_python<mx::OMPParallelMasterTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCArrayLiteral>>(gap::generator<mx::ObjCArrayLiteral>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRootClassAttrSpelling>::Type>
+from_python<mx::ObjCRootClassAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FriendDecl>>(std::optional<mx::FriendDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDistributeParallelForDirective>::Type>
+from_python<mx::OMPTargetTeamsDistributeParallelForDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::StructGEPOp>(mx::ir::ll::StructGEPOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRuntimeNameAttrSpelling>::Type>
+from_python<mx::ObjCRuntimeNameAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FriendDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::FriendDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRuntimeVisibleAttrSpelling>::Type>
+from_python<mx::ObjCRuntimeVisibleAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::StructGEPOp>>(std::optional<mx::ir::ll::StructGEPOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetTeamsDistributeDirective>::Type>
+from_python<mx::OMPTargetTeamsDistributeDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CmseNSCallAttr>(mx::CmseNSCallAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSubclassingRestrictedAttrSpelling>::Type>
+from_python<mx::ObjCSubclassingRestrictedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CmseNSCallAttr>>(gap::generator<mx::CmseNSCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetSimdDirective>::Type>
+from_python<mx::OMPTargetSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCArrayLiteral>>(std::optional<mx::ObjCArrayLiteral>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLAccessAttrSpelling>::Type>
+from_python<mx::OpenCLAccessAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OwnershipAttr>>(std::optional<mx::OwnershipAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetParallelGenericLoopDirective>::Type>
+from_python<mx::OMPTargetParallelGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLAnnotationAttr>(mx::HLSLAnnotationAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLConstantAddressSpaceAttrSpelling>::Type>
+from_python<mx::OpenCLConstantAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCArrayLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCArrayLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGenericAddressSpaceAttrSpelling>::Type>
+from_python<mx::OpenCLGenericAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLAnnotationAttr>>(gap::generator<mx::HLSLAnnotationAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetParallelForSimdDirective>::Type>
+from_python<mx::OMPTargetParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::ScopeOp>(mx::ir::ll::ScopeOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalAddressSpaceAttrSpelling>::Type>
+from_python<mx::OpenCLGlobalAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::ReturnOp>(mx::ir::ll::ReturnOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPTargetParallelForDirective>::Type>
+from_python<mx::OMPTargetParallelForDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::ReturnOp>>(std::optional<mx::ir::ll::ReturnOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling>::Type>
+from_python<mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CmseNSCallAttr>>(std::optional<mx::CmseNSCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPSimdDirective>::Type>
+from_python<mx::OMPSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConceptSpecializationExpr>(mx::ConceptSpecializationExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalHostAddressSpaceAttrSpelling>::Type>
+from_python<mx::OpenCLGlobalHostAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ChooseExpr>(mx::ChooseExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLKernelAttrSpelling>::Type>
+from_python<mx::OpenCLKernelAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConceptSpecializationExpr>>(gap::generator<mx::ConceptSpecializationExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMasterTaskLoopSimdDirective>::Type>
+from_python<mx::OMPParallelMasterTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLAnnotationAttr>>(std::optional<mx::HLSLAnnotationAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLLocalAddressSpaceAttrSpelling>::Type>
+from_python<mx::OpenCLLocalAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OwnerAttr>(mx::OwnerAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMaskedTaskLoopSimdDirective>::Type>
+from_python<mx::OMPParallelMaskedTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::ScopeOp>>(std::optional<mx::ir::ll::ScopeOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLPrivateAddressSpaceAttrSpelling>::Type>
+from_python<mx::OpenCLPrivateAddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLIntelReqdSubGroupSizeAttr>(mx::OpenCLIntelReqdSubGroupSizeAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelMaskedTaskLoopDirective>::Type>
+from_python<mx::OMPParallelMaskedTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OwnerAttr>>(gap::generator<mx::OwnerAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OptimizeNoneAttrSpelling>::Type>
+from_python<mx::OptimizeNoneAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BTFTypeTagAttr>(mx::BTFTypeTagAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadableAttrSpelling>::Type>
+from_python<mx::OverloadableAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmStreamingAttr>(mx::ArmStreamingAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelGenericLoopDirective>::Type>
+from_python<mx::OMPParallelGenericLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::ScopeRecurseOp>(mx::ir::ll::ScopeRecurseOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OwnershipAttrOwnershipKind>::Type>
+from_python<mx::OwnershipAttrOwnershipKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BTFTypeTagAttr>>(gap::generator<mx::BTFTypeTagAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelForSimdDirective>::Type>
+from_python<mx::OMPParallelForSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConceptSpecializationExpr>>(std::optional<mx::ConceptSpecializationExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OwnershipAttrSpelling>::Type>
+from_python<mx::OwnershipAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::ScopeRecurseOp>>(std::optional<mx::ir::ll::ScopeRecurseOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPParallelForDirective>::Type>
+from_python<mx::OMPParallelForDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ClassTemplateDecl>(mx::ClassTemplateDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PackedAttrSpelling>::Type>
+from_python<mx::PackedAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::ScopeRetOp>(mx::ir::ll::ScopeRetOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParamTypestateAttrConsumedState>::Type>
+from_python<mx::ParamTypestateAttrConsumedState>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ClassTemplateDecl>>(std::optional<mx::ClassTemplateDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMasterTaskLoopSimdDirective>::Type>
+from_python<mx::OMPMasterTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLSV_GroupIndexAttr>(mx::HLSLSV_GroupIndexAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParamTypestateAttrSpelling>::Type>
+from_python<mx::ParamTypestateAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ConceptSpecializationExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ConceptSpecializationExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMasterTaskLoopDirective>::Type>
+from_python<mx::OMPMasterTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HIPManagedAttr>(mx::HIPManagedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PascalAttrSpelling>::Type>
+from_python<mx::PascalAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OwnerAttr>>(std::optional<mx::OwnerAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMaskedTaskLoopSimdDirective>::Type>
+from_python<mx::OMPMaskedTaskLoopSimdDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::StoreOp>(mx::ir::ll::StoreOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PassObjectSizeAttrSpelling>::Type>
+from_python<mx::PassObjectSizeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLSV_GroupIndexAttr>>(gap::generator<mx::HLSLSV_GroupIndexAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PatchableFunctionEntryAttrSpelling>::Type>
+from_python<mx::PatchableFunctionEntryAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ClassTemplateDecl>>(gap::generator<mx::ClassTemplateDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPMaskedTaskLoopDirective>::Type>
+from_python<mx::OMPMaskedTaskLoopDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::ScopeRetOp>>(std::optional<mx::ir::ll::ScopeRetOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PcsAttrPCSType>::Type>
+from_python<mx::PcsAttrPCSType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPIteratorExpr>(mx::OMPIteratorExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Designator>::Type>
+from_python<mx::Designator>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPArraySectionExpr>(mx::OMPArraySectionExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPInteropDirective>::Type>
+from_python<mx::OMPInteropDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPIteratorExpr>>(gap::generator<mx::OMPIteratorExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PcsAttrSpelling>::Type>
+from_python<mx::PcsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BTFTypeTagAttr>>(std::optional<mx::BTFTypeTagAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Designator>>::Type>
+from_python<std::optional<mx::Designator>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::StoreOp>>(std::optional<mx::ir::ll::StoreOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPFlushDirective>::Type>
+from_python<mx::OMPFlushDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLSV_GroupIndexAttr>>(std::optional<mx::HLSLSV_GroupIndexAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PreferredNameAttrSpelling>::Type>
+from_python<mx::PreferredNameAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OverrideAttr>(mx::OverrideAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PreferredTypeAttrSpelling>::Type>
+from_python<mx::PreferredTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ClassTemplateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ClassTemplateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCanonicalLoop>::Type>
+from_python<mx::OMPCanonicalLoop>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLKernelAttr>(mx::OpenCLKernelAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PreserveAllAttrSpelling>::Type>
+from_python<mx::PreserveAllAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OverrideAttr>>(gap::generator<mx::OverrideAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclRefExpr>::Type>
+from_python<mx::DeclRefExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPIteratorExpr>>(std::optional<mx::OMPIteratorExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PreserveMostAttrSpelling>::Type>
+from_python<mx::PreserveMostAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::SubscriptOp>(mx::ir::ll::SubscriptOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NullStmt>::Type>
+from_python<mx::NullStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::SubscriptOp>>(std::optional<mx::ir::ll::SubscriptOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PtGuardedVarAttrSpelling>::Type>
+from_python<mx::PtGuardedVarAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPIteratorExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPIteratorExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PureAttrSpelling>::Type>
+from_python<mx::PureAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmStreamingCompatibleAttr>(mx::ArmStreamingCompatibleAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSDependentExistsStmt>::Type>
+from_python<mx::MSDependentExistsStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmPreservesAttr>(mx::ArmPreservesAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedTypeDestructionKind>::Type>
+from_python<mx::QualifiedTypeDestructionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmStreamingCompatibleAttr>>(gap::generator<mx::ArmStreamingCompatibleAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IndirectGotoStmt>::Type>
+from_python<mx::IndirectGotoStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLSV_DispatchThreadIDAttr>(mx::HLSLSV_DispatchThreadIDAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedTypeNonConstantStorageReason>::Type>
+from_python<mx::QualifiedTypeNonConstantStorageReason>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GuardedVarAttr>(mx::GuardedVarAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LabelDecl>::Type>
+from_python<mx::LabelDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLSV_DispatchThreadIDAttr>>(gap::generator<mx::HLSLSV_DispatchThreadIDAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedTypePrimitiveCopyKind>::Type>
+from_python<mx::QualifiedTypePrimitiveCopyKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OverrideAttr>>(std::optional<mx::OverrideAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedTypePrimitiveDefaultInitializeKind>::Type>
+from_python<mx::QualifiedTypePrimitiveDefaultInitializeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ImplicitConceptSpecializationDecl>(mx::ImplicitConceptSpecializationDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LabelStmt>::Type>
+from_python<mx::LabelStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ll::UninitializedVarOp>(mx::ir::ll::UninitializedVarOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RISCVInterruptAttrInterruptType>::Type>
+from_python<mx::RISCVInterruptAttrInterruptType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImplicitConceptSpecializationDecl>>(gap::generator<mx::ImplicitConceptSpecializationDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXTryStmt>::Type>
+from_python<mx::CXXTryStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::ll::UninitializedVarOp>>(std::optional<mx::ir::ll::UninitializedVarOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RISCVInterruptAttrSpelling>::Type>
+from_python<mx::RISCVInterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmStreamingCompatibleAttr>>(std::optional<mx::ArmStreamingCompatibleAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IfStmt>::Type>
+from_python<mx::IfStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::Attribute>(mx::ir::hl::Attribute) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RandomizeLayoutAttrSpelling>::Type>
+from_python<mx::RandomizeLayoutAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::Attribute>>(std::optional<mx::ir::hl::Attribute>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReadOnlyPlacementAttrSpelling>::Type>
+from_python<mx::ReadOnlyPlacementAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLSV_DispatchThreadIDAttr>>(std::optional<mx::HLSLSV_DispatchThreadIDAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclStmt>::Type>
+from_python<mx::DeclStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OptimizeNoneAttr>>(gap::generator<mx::OptimizeNoneAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RegCallAttrSpelling>::Type>
+from_python<mx::RegCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImplicitConceptSpecializationDecl>>(std::optional<mx::ImplicitConceptSpecializationDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GotoStmt>::Type>
+from_python<mx::GotoStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AnnotationAttr>(mx::ir::hl::AnnotationAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReinitializesAttrSpelling>::Type>
+from_python<mx::ReinitializesAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OptimizeNoneAttr>(mx::OptimizeNoneAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ForStmt>::Type>
+from_python<mx::ForStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CodeModelAttr>>(gap::generator<mx::CodeModelAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReleaseCapabilityAttrSpelling>::Type>
+from_python<mx::ReleaseCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTeamsDistributeSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTeamsDistributeSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReleaseHandleAttrSpelling>::Type>
+from_python<mx::ReleaseHandleAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftErrorAttr>>(gap::generator<mx::SwiftErrorAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DoStmt>::Type>
+from_python<mx::DoStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IfNotDefinedMacroDirective>>(gap::generator<mx::IfNotDefinedMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RequiresCapabilityAttrSpelling>::Type>
+from_python<mx::RequiresCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FPToUIOp>>(std::optional<mx::ir::llvm::FPToUIOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroutineBodyStmt>::Type>
+from_python<mx::CoroutineBodyStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CodeModelAttr>>(std::optional<mx::CodeModelAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RestrictAttrSpelling>::Type>
+from_python<mx::RestrictAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AcquiredAfterAttr>>(gap::generator<mx::AcquiredAfterAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoreturnStmt>::Type>
+from_python<mx::CoreturnStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskDirective>>(gap::generator<mx::OMPTaskDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RetainAttrSpelling>::Type>
+from_python<mx::RetainAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FRemOp>(mx::ir::llvm::FRemOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnTypestateAttrConsumedState>::Type>
+from_python<mx::ReturnTypestateAttrConsumedState>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FPTruncOp>(mx::ir::llvm::FPTruncOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ContinueStmt>::Type>
+from_python<mx::ContinueStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftErrorAttr>>(std::optional<mx::SwiftErrorAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnTypestateAttrSpelling>::Type>
+from_python<mx::ReturnTypestateAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FPTruncOp>>(std::optional<mx::ir::llvm::FPTruncOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXCatchStmt>::Type>
+from_python<mx::CXXCatchStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IfNotDefinedMacroDirective>>(std::optional<mx::IfNotDefinedMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnsNonNullAttrSpelling>::Type>
+from_python<mx::ReturnsNonNullAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FSubOp>(mx::ir::llvm::FSubOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXForRangeStmt>::Type>
+from_python<mx::CXXForRangeStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskDirective>>(std::optional<mx::OMPTaskDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReturnsTwiceAttrSpelling>::Type>
+from_python<mx::ReturnsTwiceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AcquiredAfterAttr>>(std::optional<mx::AcquiredAfterAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLKernelAttrSpelling>::Type>
+from_python<mx::SYCLKernelAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FRemOp>>(std::optional<mx::ir::llvm::FRemOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BreakStmt>::Type>
+from_python<mx::BreakStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTaskDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTaskDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLSpecialClassAttrSpelling>::Type>
+from_python<mx::SYCLSpecialClassAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CmseNSEntryAttr>>(gap::generator<mx::CmseNSEntryAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AsmStmt>::Type>
+from_python<mx::AsmStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDistributeParallelForSimdDirective>>(gap::generator<mx::OMPTeamsDistributeParallelForSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ScopedLockableAttrSpelling>::Type>
+from_python<mx::ScopedLockableAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclarativeDirectiveDecl>>(gap::generator<mx::OMPDeclarativeDirectiveDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSAsmStmt>::Type>
+from_python<mx::MSAsmStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftCallAttr>>(gap::generator<mx::SwiftCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SectionAttrSpelling>::Type>
+from_python<mx::SectionAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IfStmt>(mx::IfStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SelectAnyAttrSpelling>::Type>
+from_python<mx::SelectAnyAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXParenListInitExpr>>(gap::generator<mx::CXXParenListInitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GCCAsmStmt>::Type>
+from_python<mx::GCCAsmStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IfStmt>>(gap::generator<mx::IfStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SentinelAttrSpelling>::Type>
+from_python<mx::SentinelAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IfDefinedMacroDirective>(mx::IfDefinedMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StringLiteral>::Type>
+from_python<mx::StringLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FenceOp>(mx::ir::llvm::FenceOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SetTypestateAttrConsumedState>::Type>
+from_python<mx::SetTypestateAttrConsumedState>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IfDefinedMacroDirective>>(gap::generator<mx::IfDefinedMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AddrLabelExpr>::Type>
+from_python<mx::AddrLabelExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FSubOp>>(std::optional<mx::ir::llvm::FSubOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SetTypestateAttrSpelling>::Type>
+from_python<mx::SetTypestateAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CmseNSEntryAttr>>(std::optional<mx::CmseNSEntryAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SpeculativeLoadHardeningAttrSpelling>::Type>
+from_python<mx::SpeculativeLoadHardeningAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AcquireHandleAttr>>(gap::generator<mx::AcquireHandleAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WhileStmt>::Type>
+from_python<mx::WhileStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDistributeParallelForSimdDirective>>(std::optional<mx::OMPTeamsDistributeParallelForSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXBaseSpecifier>::Type>
+from_python<mx::CXXBaseSpecifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclarativeDirectiveDecl>>(std::optional<mx::OMPDeclarativeDirectiveDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StandaloneDebugAttrSpelling>::Type>
+from_python<mx::StandaloneDebugAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftCallAttr>>(std::optional<mx::SwiftCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DesignatedInitUpdateExpr>::Type>
+from_python<mx::DesignatedInitUpdateExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXParenListInitExpr>>(std::optional<mx::CXXParenListInitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StdCallAttrSpelling>::Type>
+from_python<mx::StdCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTeamsDistributeParallelForSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTeamsDistributeParallelForSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InitListExpr>::Type>
+from_python<mx::InitListExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IfStmt>>(std::optional<mx::IfStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StmtLikelihood>::Type>
+from_python<mx::StmtLikelihood>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDeclarativeDirectiveDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDeclarativeDirectiveDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StmtKind>::Type>
+from_python<mx::StmtKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXParenListInitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXParenListInitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DesignatedInitExpr>::Type>
+from_python<mx::DesignatedInitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::IfStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::IfStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SuppressAttrSpelling>::Type>
+from_python<mx::SuppressAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FenceOp>>(std::optional<mx::ir::llvm::FenceOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentScopeDeclRefExpr>::Type>
+from_python<mx::DependentScopeDeclRefExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IfDefinedMacroDirective>>(std::optional<mx::IfDefinedMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncAttrKind>::Type>
+from_python<mx::SwiftAsyncAttrKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AcquireHandleAttr>>(std::optional<mx::AcquireHandleAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentCoawaitExpr>::Type>
+from_python<mx::DependentCoawaitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CleanupAttr>(mx::CleanupAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncAttrSpelling>::Type>
+from_python<mx::SwiftAsyncAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CleanupAttr>>(gap::generator<mx::CleanupAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncCallAttrSpelling>::Type>
+from_python<mx::SwiftAsyncCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FreezeOp>(mx::ir::llvm::FreezeOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedLookupExpr>::Type>
+from_python<mx::UnresolvedLookupExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetUpdateDirective>>(gap::generator<mx::OMPTargetUpdateDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncContextAttrSpelling>::Type>
+from_python<mx::SwiftAsyncContextAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftBridgedTypedefAttr>(mx::SwiftBridgedTypedefAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadExpr>::Type>
+from_python<mx::OverloadExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FreezeOp>>(std::optional<mx::ir::llvm::FreezeOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncErrorAttrConventionKind>::Type>
+from_python<mx::SwiftAsyncErrorAttrConventionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftBridgedTypedefAttr>>(gap::generator<mx::SwiftBridgedTypedefAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::CXXBaseSpecifier>>::Type>
+from_python<std::optional<mx::CXXBaseSpecifier>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IfMacroDirective>(mx::IfMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroutineSuspendExpr>::Type>
+from_python<mx::CoroutineSuspendExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IfMacroDirective>>(gap::generator<mx::IfMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncErrorAttrSpelling>::Type>
+from_python<mx::SwiftAsyncErrorAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::GetElementPtrOp>(mx::ir::llvm::GetElementPtrOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftCallAttrSpelling>::Type>
+from_python<mx::SwiftCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CleanupAttr>>(std::optional<mx::CleanupAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpaqueValueExpr>::Type>
+from_python<mx::OpaqueValueExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AcquireCapabilityAttr>(mx::AcquireCapabilityAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftContextAttrSpelling>::Type>
+from_python<mx::SwiftContextAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AcquireCapabilityAttr>>(gap::generator<mx::AcquireCapabilityAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoawaitExpr>::Type>
+from_python<mx::CoawaitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::GetElementPtrOp>>(std::optional<mx::ir::llvm::GetElementPtrOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftErrorAttrConventionKind>::Type>
+from_python<mx::SwiftErrorAttrConventionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetUpdateDirective>>(std::optional<mx::OMPTargetUpdateDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoyieldExpr>::Type>
+from_python<mx::CoyieldExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftBridgedTypedefAttr>>(std::optional<mx::SwiftBridgedTypedefAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftErrorResultAttrSpelling>::Type>
+from_python<mx::SwiftErrorResultAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetUpdateDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetUpdateDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<uint32_t>::Type>
+from_python<uint32_t>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDistributeParallelForDirective>>(gap::generator<mx::OMPTeamsDistributeParallelForDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftIndirectResultAttrSpelling>::Type>
+from_python<mx::SwiftIndirectResultAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPThreadPrivateDecl>>(gap::generator<mx::OMPThreadPrivateDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConvertVectorExpr>::Type>
+from_python<mx::ConvertVectorExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeclStmt>(mx::DeclStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftNewTypeAttrNewtypeKind>::Type>
+from_python<mx::SwiftNewTypeAttrNewtypeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeclStmt>>(std::optional<mx::DeclStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConceptSpecializationExpr>::Type>
+from_python<mx::ConceptSpecializationExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::GlobalCtorsOp>(mx::ir::llvm::GlobalCtorsOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<uint64_t>::Type>
+from_python<uint64_t>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXNullPtrLiteralExpr>>(gap::generator<mx::CXXNullPtrLiteralExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftNewTypeAttrSpelling>::Type>
+from_python<mx::SwiftNewTypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AcquireCapabilityAttr>>(std::optional<mx::AcquireCapabilityAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitConceptSpecializationDecl>::Type>
+from_python<mx::ImplicitConceptSpecializationDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeclStmt>>(gap::generator<mx::DeclStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SysVABIAttrSpelling>::Type>
+from_python<mx::SysVABIAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::GlobalCtorsOp>>(std::optional<mx::ir::llvm::GlobalCtorsOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<bool>::Type>
+from_python<bool>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CapturedRecordAttr>(mx::CapturedRecordAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TLSModelAttrSpelling>::Type>
+from_python<mx::TLSModelAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IfMacroDirective>>(std::optional<mx::IfMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CompoundLiteralExpr>::Type>
+from_python<mx::CompoundLiteralExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CapturedRecordAttr>>(gap::generator<mx::CapturedRecordAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetAttrSpelling>::Type>
+from_python<mx::TargetAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::GlobalDtorsOp>(mx::ir::llvm::GlobalDtorsOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ChooseExpr>::Type>
+from_python<mx::ChooseExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftBridgeAttr>(mx::SwiftBridgeAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetClonesAttrSpelling>::Type>
+from_python<mx::TargetClonesAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDistributeParallelForDirective>>(std::optional<mx::OMPTeamsDistributeParallelForDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CharacterLiteral>::Type>
+from_python<mx::CharacterLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftBridgeAttr>>(gap::generator<mx::SwiftBridgeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetVersionAttrSpelling>::Type>
+from_python<mx::TargetVersionAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPThreadPrivateDecl>>(std::optional<mx::OMPThreadPrivateDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AttrKind>::Type>
+from_python<mx::AttrKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::GlobalDtorsOp>>(std::optional<mx::ir::llvm::GlobalDtorsOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateArgumentKind>::Type>
+from_python<mx::TemplateArgumentKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTeamsDistributeParallelForDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTeamsDistributeParallelForDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CastExpr>::Type>
+from_python<mx::CastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXNullPtrLiteralExpr>>(std::optional<mx::CXXNullPtrLiteralExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TestTypestateAttrConsumedState>::Type>
+from_python<mx::TestTypestateAttrConsumedState>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::GlobalOp>(mx::ir::llvm::GlobalOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitCastExpr>::Type>
+from_python<mx::ImplicitCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPThreadPrivateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPThreadPrivateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TestTypestateAttrSpelling>::Type>
+from_python<mx::TestTypestateAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ICmpOp>(mx::ir::llvm::ICmpOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AArch64SVEPcsAttrSpelling>::Type>
+from_python<mx::AArch64SVEPcsAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXNullPtrLiteralExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXNullPtrLiteralExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclKind>::Type>
+from_python<mx::DeclKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::GlobalOp>>(std::optional<mx::ir::llvm::GlobalOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExplicitCastExpr>::Type>
+from_python<mx::ExplicitCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CapturedRecordAttr>>(std::optional<mx::CapturedRecordAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ThisCallAttrSpelling>::Type>
+from_python<mx::ThisCallAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DeclStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::DeclStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TransparentUnionAttrSpelling>::Type>
+from_python<mx::TransparentUnionAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AVRSignalAttr>(mx::AVRSignalAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXNamedCastExpr>::Type>
+from_python<mx::CXXNamedCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AVRSignalAttr>>(gap::generator<mx::AVRSignalAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TrivialABIAttrSpelling>::Type>
+from_python<mx::TrivialABIAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IncludeLikeMacroDirective>(mx::IncludeLikeMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDynamicCastExpr>::Type>
+from_python<mx::CXXDynamicCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftBridgeAttr>>(std::optional<mx::SwiftBridgeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TryAcquireCapabilityAttrSpelling>::Type>
+from_python<mx::TryAcquireCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncludeLikeMacroDirective>>(gap::generator<mx::IncludeLikeMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConstCastExpr>::Type>
+from_python<mx::CXXConstCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDirective>(mx::OMPTargetTeamsDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeScalarTypeKind>::Type>
+from_python<mx::TypeScalarTypeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetExitDataDirective>(mx::OMPTargetExitDataDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeKind>::Type>
+from_python<mx::TypeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDirective>>(gap::generator<mx::OMPTargetTeamsDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXAddrspaceCastExpr>::Type>
+from_python<mx::CXXAddrspaceCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AVRSignalAttr>>(std::optional<mx::AVRSignalAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeTagForDatatypeAttrSpelling>::Type>
+from_python<mx::TypeTagForDatatypeAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ICmpOp>>(std::optional<mx::ir::llvm::ICmpOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXStaticCastExpr>::Type>
+from_python<mx::CXXStaticCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CapabilityAttr>(mx::CapabilityAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeVisibilityAttrSpelling>::Type>
+from_python<mx::TypeVisibilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CapabilityAttr>>(gap::generator<mx::CapabilityAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXReinterpretCastExpr>::Type>
+from_python<mx::CXXReinterpretCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDirective>>(std::optional<mx::OMPTargetTeamsDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeVisibilityAttrVisibilityType>::Type>
+from_python<mx::TypeVisibilityAttrVisibilityType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAttrAttr>(mx::SwiftAttrAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryTransformTypeUTTKind>::Type>
+from_python<mx::UnaryTransformTypeUTTKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncludeLikeMacroDirective>>(std::optional<mx::IncludeLikeMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXFunctionalCastExpr>::Type>
+from_python<mx::CXXFunctionalCastExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAttrAttr>>(gap::generator<mx::SwiftAttrAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCGCAttr>::Type>
+from_python<mx::ObjCGCAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetTeamsDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetTeamsDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MemberExpr>::Type>
+from_python<mx::MemberExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDistributeDirective>(mx::OMPTeamsDistributeDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoDerefAttr>::Type>
+from_python<mx::NoDerefAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskLoopDirective>(mx::OMPTaskLoopDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MatrixSubscriptExpr>::Type>
+from_python<mx::MatrixSubscriptExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::InlineAsmOp>(mx::ir::llvm::InlineAsmOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLParamModifierAttr>::Type>
+from_python<mx::HLSLParamModifierAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDistributeDirective>>(gap::generator<mx::OMPTeamsDistributeDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MaterializeTemporaryExpr>::Type>
+from_python<mx::MaterializeTemporaryExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::InlineAsmOp>>(std::optional<mx::ir::llvm::InlineAsmOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLGroupSharedAddressSpaceAttr>::Type>
+from_python<mx::HLSLGroupSharedAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CapabilityAttr>>(std::optional<mx::CapabilityAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LifetimeExtendedTemporaryDecl>::Type>
+from_python<mx::LifetimeExtendedTemporaryDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AVRInterruptAttr>(mx::AVRInterruptAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CmseNSCallAttr>::Type>
+from_python<mx::CmseNSCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUWavesPerEUAttr>(mx::AMDGPUWavesPerEUAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSPropertySubscriptExpr>::Type>
+from_python<mx::MSPropertySubscriptExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPRequiresDecl>(mx::OMPRequiresDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::Type>>::Type>
+from_python<std::optional<mx::Type>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AVRInterruptAttr>>(gap::generator<mx::AVRInterruptAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnnotateTypeAttr>::Type>
+from_python<mx::AnnotateTypeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXNoexceptExpr>(mx::CXXNoexceptExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSPropertyRefExpr>::Type>
+from_python<mx::MSPropertyRefExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TranslationUnitDecl>(mx::TranslationUnitDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFTypeTagAttr>::Type>
+from_python<mx::BTFTypeTagAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXInheritedCtorInitExpr>(mx::CXXInheritedCtorInitExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSPropertyDecl>::Type>
+from_python<mx::MSPropertyDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPRequiresDecl>>(gap::generator<mx::OMPRequiresDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmStreamingCompatibleAttr>::Type>
+from_python<mx::ArmStreamingCompatibleAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXNoexceptExpr>>(gap::generator<mx::CXXNoexceptExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LambdaExpr>::Type>
+from_python<mx::LambdaExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAttrAttr>>(std::optional<mx::SwiftAttrAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmStreamingAttr>::Type>
+from_python<mx::ArmStreamingAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ImportMacroDirective>(mx::ImportMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IntegerLiteral>::Type>
+from_python<mx::IntegerLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImportMacroDirective>>(gap::generator<mx::ImportMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmPreservesAttr>::Type>
+from_python<mx::ArmPreservesAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::InsertElementOp>(mx::ir::llvm::InsertElementOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitValueInitExpr>::Type>
+from_python<mx::ImplicitValueInitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDistributeDirective>>(std::optional<mx::OMPTeamsDistributeDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmOutAttr>::Type>
+from_python<mx::ArmOutAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::InsertElementOp>>(std::optional<mx::ir::llvm::InsertElementOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ImaginaryLiteral>::Type>
+from_python<mx::ImaginaryLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTeamsDistributeDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTeamsDistributeDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmMveStrictPolymorphismAttr>::Type>
+from_python<mx::ArmMveStrictPolymorphismAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AVRInterruptAttr>>(std::optional<mx::AVRInterruptAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GenericSelectionExpr>::Type>
+from_python<mx::GenericSelectionExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPRequiresDecl>>(std::optional<mx::OMPRequiresDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::TypeKind>>::Type>
+from_python<std::span<const mx::TypeKind>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXNoexceptExpr>>(std::optional<mx::CXXNoexceptExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmInOutAttr>::Type>
+from_python<mx::ArmInOutAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GotoStmt>>(gap::generator<mx::GotoStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GNUNullExpr>::Type>
+from_python<mx::GNUNullExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPRequiresDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPRequiresDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmInAttr>::Type>
+from_python<mx::ArmInAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CallbackAttr>(mx::CallbackAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionParmPackExpr>::Type>
+from_python<mx::FunctionParmPackExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXNoexceptExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXNoexceptExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AddressSpaceAttr>::Type>
+from_python<mx::AddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXX11NoReturnAttr>(mx::CXX11NoReturnAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FullExpr>::Type>
+from_python<mx::FullExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CallbackAttr>>(gap::generator<mx::CallbackAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::WebAssemblyFuncrefAttr>::Type>
+from_python<mx::WebAssemblyFuncrefAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncNameAttr>(mx::SwiftAsyncNameAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExprWithCleanups>::Type>
+from_python<mx::ExprWithCleanups>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncCallAttr>(mx::SwiftAsyncCallAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UPtrAttr>::Type>
+from_python<mx::UPtrAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::InsertValueOp>(mx::ir::llvm::InsertValueOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstantExpr>::Type>
+from_python<mx::ConstantExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncNameAttr>>(gap::generator<mx::SwiftAsyncNameAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeNullableResultAttr>::Type>
+from_python<mx::TypeNullableResultAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::InsertValueOp>>(std::optional<mx::ir::llvm::InsertValueOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FloatingLiteral>::Type>
+from_python<mx::FloatingLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetParallelDirective>(mx::OMPTargetParallelDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeNullableAttr>::Type>
+from_python<mx::TypeNullableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetEnterDataDirective>(mx::OMPTargetEnterDataDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FixedPointLiteral>::Type>
+from_python<mx::FixedPointLiteral>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImportMacroDirective>>(std::optional<mx::ImportMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeNullUnspecifiedAttr>::Type>
+from_python<mx::TypeNullUnspecifiedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetParallelDirective>>(gap::generator<mx::OMPTargetParallelDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExtVectorElementExpr>::Type>
+from_python<mx::ExtVectorElementExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TokenContext>(mx::TokenContext) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::AttrKind>>::Type>
+from_python<std::span<const mx::AttrKind>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GotoStmt>>(std::optional<mx::GotoStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeNonNullAttr>::Type>
+from_python<mx::TypeNonNullAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ARMInterruptAttr>(mx::ARMInterruptAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExpressionTraitExpr>::Type>
+from_python<mx::ExpressionTraitExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUNumVGPRAttr>(mx::AMDGPUNumVGPRAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ThreadAttr>::Type>
+from_python<mx::ThreadAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ARMInterruptAttr>>(gap::generator<mx::ARMInterruptAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AttributedStmt>::Type>
+from_python<mx::AttributedStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CallbackAttr>>(std::optional<mx::CallbackAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftVersionedRemovalAttr>::Type>
+from_python<mx::SwiftVersionedRemovalAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::GotoStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::GotoStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwitchStmt>::Type>
+from_python<mx::SwitchStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::IntToPtrOp>(mx::ir::llvm::IntToPtrOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftVersionedAdditionAttr>::Type>
+from_python<mx::SwiftVersionedAdditionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncNameAttr>>(std::optional<mx::SwiftAsyncNameAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwitchCase>::Type>
+from_python<mx::SwitchCase>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::IntToPtrOp>>(std::optional<mx::ir::llvm::IntToPtrOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftObjCMembersAttr>::Type>
+from_python<mx::SwiftObjCMembersAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetParallelDirective>>(std::optional<mx::OMPTargetParallelDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DefaultStmt>::Type>
+from_python<mx::DefaultStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IncludeMacrosMacroDirective>(mx::IncludeMacrosMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StmtAttr>::Type>
+from_python<mx::StmtAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IncludeNextMacroDirective>(mx::IncludeNextMacroDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CaseStmt>::Type>
+from_python<mx::CaseStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetParallelDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetParallelDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLUnrollHintAttr>::Type>
+from_python<mx::OpenCLUnrollHintAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncludeMacrosMacroDirective>>(gap::generator<mx::IncludeMacrosMacroDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AccessSpecDecl>::Type>
+from_python<mx::AccessSpecDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::InvokeOp>(mx::ir::llvm::InvokeOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MustTailAttr>::Type>
+from_python<mx::MustTailAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ARMInterruptAttr>>(std::optional<mx::ARMInterruptAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclarativeDirectiveDecl>::Type>
+from_python<mx::OMPDeclarativeDirectiveDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskLoopSimdDirective>(mx::OMPTaskLoopSimdDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LikelyAttr>::Type>
+from_python<mx::LikelyAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsGenericLoopDirective>(mx::OMPTargetTeamsGenericLoopDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPThreadPrivateDecl>::Type>
+from_python<mx::OMPThreadPrivateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskLoopSimdDirective>>(gap::generator<mx::OMPTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FallThroughAttr>::Type>
+from_python<mx::FallThroughAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::InvokeOp>>(std::optional<mx::ir::llvm::InvokeOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPRequiresDecl>::Type>
+from_python<mx::OMPRequiresDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CallableWhenAttr>(mx::CallableWhenAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeAlignAttr>::Type>
+from_python<mx::CodeAlignAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDASharedAttr>(mx::CUDASharedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPAllocateDecl>::Type>
+from_python<mx::OMPAllocateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CallableWhenAttr>>(gap::generator<mx::CallableWhenAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnlikelyAttr>::Type>
+from_python<mx::UnlikelyAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPAllocateDecl>(mx::OMPAllocateDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TranslationUnitDecl>::Type>
+from_python<mx::TranslationUnitDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TopLevelStmtDecl>(mx::TopLevelStmtDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RenderScriptKernelAttr>::Type>
+from_python<mx::RenderScriptKernelAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPAllocateDecl>>(gap::generator<mx::OMPAllocateDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TopLevelStmtDecl>::Type>
+from_python<mx::TopLevelStmtDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncErrorAttr>(mx::SwiftAsyncErrorAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadableAttr>::Type>
+from_python<mx::OverloadableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXNewExpr>(mx::CXXNewExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StaticAssertDecl>::Type>
+from_python<mx::StaticAssertDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FuncOp>(mx::ir::llvm::FuncOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLAccessAttr>::Type>
+from_python<mx::OpenCLAccessAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXFoldExpr>(mx::CXXFoldExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaDetectMismatchDecl>::Type>
+from_python<mx::PragmaDetectMismatchDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncAttr>(mx::SwiftAsyncAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRuntimeVisibleAttr>::Type>
+from_python<mx::ObjCRuntimeVisibleAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXNewExpr>>(gap::generator<mx::CXXNewExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaCommentDecl>::Type>
+from_python<mx::PragmaCommentDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncErrorAttr>>(gap::generator<mx::SwiftAsyncErrorAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCRuntimeNameAttr>::Type>
+from_python<mx::ObjCRuntimeNameAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskLoopSimdDirective>>(std::optional<mx::OMPTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLBufferDecl>::Type>
+from_python<mx::HLSLBufferDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DefaultVisiblityExportMapping>(mx::DefaultVisiblityExportMapping) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNonRuntimeProtocolAttr>::Type>
+from_python<mx::ObjCNonRuntimeProtocolAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LValueReferenceType>>(std::optional<mx::LValueReferenceType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingEnumDecl>::Type>
+from_python<mx::UsingEnumDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DesignatorKind>(mx::DesignatorKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCNonLazyClassAttr>::Type>
+from_python<mx::ObjCNonLazyClassAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DiagnosticLevelMask>(mx::DiagnosticLevelMask) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumDecl>::Type>
+from_python<mx::EnumDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ElaboratedTypeKeyword>(mx::ElaboratedTypeKeyword) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDirectMembersAttr>::Type>
+from_python<mx::ObjCDirectMembersAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPArrayShapingExpr>>(gap::generator<mx::OMPArrayShapingExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumConstantDecl>::Type>
+from_python<mx::EnumConstantDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EscapeChar>(mx::EscapeChar) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoBuiltinAttr>::Type>
+from_python<mx::NoBuiltinAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExceptionHandlingKind>(mx::ExceptionHandlingKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingDecl>::Type>
+from_python<mx::UsingDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExceptionSpecificationType>(mx::ExceptionSpecificationType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDirectAttr>::Type>
+from_python<mx::ObjCDirectAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::QualifiedType>>(gap::generator<mx::QualifiedType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedUsingValueDecl>::Type>
+from_python<mx::UnresolvedUsingValueDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExcessPrecisionKind>(mx::ExcessPrecisionKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCDesignatedInitializerAttr>::Type>
+from_python<mx::ObjCDesignatedInitializerAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPArrayShapingExpr>>(std::optional<mx::OMPArrayShapingExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnnamedGlobalConstantDecl>::Type>
+from_python<mx::UnnamedGlobalConstantDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExplicitSpecKind>(mx::ExplicitSpecKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCClassStubAttr>::Type>
+from_python<mx::ObjCClassStubAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPArrayShapingExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPArrayShapingExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateParamObjectDecl>::Type>
+from_python<mx::TemplateParamObjectDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprDependence>(mx::ExprDependence) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBoxableAttr>::Type>
+from_python<mx::ObjCBoxableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprObjectKind>(mx::ExprObjectKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareReductionDecl>::Type>
+from_python<mx::OMPDeclareReductionDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TokenRange>(mx::TokenRange) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPReferencedVarAttr>::Type>
+from_python<mx::OMPReferencedVarAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::QualifiedType>>(std::optional<mx::QualifiedType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCapturedExprDecl>::Type>
+from_python<mx::OMPCapturedExprDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprOffsets>(mx::ExprOffsets) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareSimdDeclAttr>::Type>
+from_python<mx::OMPDeclareSimdDeclAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprValueKind>(mx::ExprValueKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DecompositionDecl>::Type>
+from_python<mx::DecompositionDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExpressionTrait>(mx::ExpressionTrait) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPCaptureKindAttr>::Type>
+from_python<mx::OMPCaptureKindAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExtKind>(mx::ExtKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BindingDecl>::Type>
+from_python<mx::BindingDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExtendArgsKind>(mx::ExtendArgsKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoEscapeAttr>::Type>
+from_python<mx::NoEscapeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FPEvalMethodKind>(mx::FPEvalMethodKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VarTemplateSpecializationDecl>::Type>
+from_python<mx::VarTemplateSpecializationDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FPExceptionModeKind>(mx::FPExceptionModeKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ModeAttr>::Type>
+from_python<mx::ModeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FPModeKind>(mx::FPModeKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VarTemplatePartialSpecializationDecl>::Type>
+from_python<mx::VarTemplatePartialSpecializationDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Flags>(mx::Flags) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LoopHintAttr>::Type>
+from_python<mx::LoopHintAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GC>(mx::GC) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConversionDecl>::Type>
+from_python<mx::CXXConversionDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GPUDefaultStreamKind>(mx::GPUDefaultStreamKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Reference>::Type>
+from_python<mx::Reference>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GCMode>(mx::GCMode) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LoaderUninitializedAttr>::Type>
+from_python<mx::LoaderUninitializedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GVALinkage>(mx::GVALinkage) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDeductionGuideDecl>::Type>
+from_python<mx::CXXDeductionGuideDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GetBuiltinTypeError>(mx::GetBuiltinTypeError) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateArgument>::Type>
+from_python<mx::TemplateArgument>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLLangStd>(mx::HLSLLangStd) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InitSegAttr>::Type>
+from_python<mx::InitSegAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ID>(mx::ID) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCAtDefsFieldDecl>::Type>
+from_python<mx::ObjCAtDefsFieldDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPArraySectionExpr>>(gap::generator<mx::OMPArraySectionExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IBOutletCollectionAttr>::Type>
+from_python<mx::IBOutletCollectionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IdentifierInfoFlag>(mx::IdentifierInfoFlag) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclarativeDirectiveValueDecl>::Type>
+from_python<mx::OMPDeclarativeDirectiveValueDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IfStatementKind>(mx::IfStatementKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenRange>::Type>
+from_python<mx::TokenRange>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PointerType>>(gap::generator<mx::PointerType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenTree>::Type>
+from_python<mx::TokenTree>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ImplicitParamKind>(mx::ImplicitParamKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IBOutletAttr>::Type>
+from_python<mx::IBOutletAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InClassInitStyle>(mx::InClassInitStyle) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareMapperDecl>::Type>
+from_python<mx::OMPDeclareMapperDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InheritedDesignatedInitializersState>(mx::InheritedDesignatedInitializersState) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IBActionAttr>::Type>
+from_python<mx::IBActionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InitStorageKind>(mx::InitStorageKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstructorUsingShadowDecl>::Type>
+from_python<mx::ConstructorUsingShadowDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InlineVariableDefinitionKind>(mx::InlineVariableDefinitionKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HotAttr>::Type>
+from_python<mx::HotAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PointerType>>(std::optional<mx::PointerType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingPackDecl>::Type>
+from_python<mx::UsingPackDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InterestingIdentifierKind>(mx::InterestingIdentifierKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLShaderAttr>::Type>
+from_python<mx::HLSLShaderAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPArraySectionExpr>>(std::optional<mx::OMPArraySectionExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UsingDirectiveDecl>::Type>
+from_python<mx::UsingDirectiveDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPArraySectionExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPArraySectionExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<ProxyTokenTreeVisitor>::Type>
+from_python<ProxyTokenTreeVisitor>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LambdaCaptureDefault>(mx::LambdaCaptureDefault) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLResourceBindingAttr>::Type>
+from_python<mx::HLSLResourceBindingAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Kinds>(mx::Kinds) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NamespaceDecl>::Type>
+from_python<mx::NamespaceDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LambdaCaptureKind>(mx::LambdaCaptureKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLResourceAttr>::Type>
+from_python<mx::HLSLResourceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LangAS>(mx::LangAS) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnresolvedUsingIfExistsDecl>::Type>
+from_python<mx::UnresolvedUsingIfExistsDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LangFeatures>(mx::LangFeatures) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLNumThreadsAttr>::Type>
+from_python<mx::HLSLNumThreadsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PipeType>(mx::PipeType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ClassTemplateSpecializationDecl>::Type>
+from_python<mx::ClassTemplateSpecializationDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Language>(mx::Language) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLAnnotationAttr>::Type>
+from_python<mx::HLSLAnnotationAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PipeType>>(gap::generator<mx::PipeType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ClassTemplatePartialSpecializationDecl>::Type>
+from_python<mx::ClassTemplatePartialSpecializationDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LanguageLinkage>(mx::LanguageLinkage) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLSV_GroupIndexAttr>::Type>
+from_python<mx::HLSLSV_GroupIndexAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LaxVectorConversionKind>(mx::LaxVectorConversionKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypedefDecl>::Type>
+from_python<mx::TypedefDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PipeType>>(std::optional<mx::PipeType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HLSLSV_DispatchThreadIDAttr>::Type>
+from_python<mx::HLSLSV_DispatchThreadIDAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Level>(mx::Level) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeAliasDecl>::Type>
+from_python<mx::TypeAliasDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Linkage>(mx::Linkage) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::HIPManagedAttr>::Type>
+from_python<mx::HIPManagedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LinkageSpecLanguageIDs>(mx::LinkageSpecLanguageIDs) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeAliasTemplateDecl>::Type>
+from_python<mx::TypeAliasTemplateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSInheritanceModel>(mx::MSInheritanceModel) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GuardedVarAttr>::Type>
+from_python<mx::GuardedVarAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSVCMajorVersion>(mx::MSVCMajorVersion) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinTemplateDecl>::Type>
+from_python<mx::BuiltinTemplateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParenType>(mx::ParenType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GuardedByAttr>::Type>
+from_python<mx::GuardedByAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoInitExpr>(mx::NoInitExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateTemplateParmDecl>::Type>
+from_python<mx::TemplateTemplateParmDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MatrixSubscriptExpr>(mx::MatrixSubscriptExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::GNUInlineAttr>::Type>
+from_python<mx::GNUInlineAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSVtorDispMode>(mx::MSVtorDispMode) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCCompatibleAliasDecl>::Type>
+from_python<mx::ObjCCompatibleAliasDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParenType>>(gap::generator<mx::ParenType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionReturnThunksAttr>::Type>
+from_python<mx::FunctionReturnThunksAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoInitExpr>>(gap::generator<mx::NoInitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NamespaceAliasDecl>::Type>
+from_python<mx::NamespaceAliasDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MethodRefFlags>(mx::MethodRefFlags) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FormatAttr>::Type>
+from_python<mx::FormatAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ModifiableType>(mx::ModifiableType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LinkageSpecDecl>::Type>
+from_python<mx::LinkageSpecDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MultiVersionKind>(mx::MultiVersionKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FormatArgAttr>::Type>
+from_python<mx::FormatArgAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NameKind>(mx::NameKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ImportDecl>::Type>
+from_python<mx::ImportDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NeedExtraManglingDecl>(mx::NeedExtraManglingDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FlattenAttr>::Type>
+from_python<mx::FlattenAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParenType>>(std::optional<mx::ParenType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FriendTemplateDecl>::Type>
+from_python<mx::FriendTemplateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NestedNameSpecifierDependence>(mx::NestedNameSpecifierDependence) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnforceTCBLeafAttr>::Type>
+from_python<mx::EnforceTCBLeafAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NonOdrUseReason>(mx::NonOdrUseReason) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FlagEnumAttr>::Type>
+from_python<mx::FlagEnumAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NonceObjCInterface>(mx::NonceObjCInterface) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FileScopeAsmDecl>::Type>
+from_python<mx::FileScopeAsmDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoInitExpr>>(std::optional<mx::NoInitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FinalAttr>::Type>
+from_python<mx::FinalAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NullabilityKind>(mx::NullabilityKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExternCContextDecl>::Type>
+from_python<mx::ExternCContextDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::NoInitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::NoInitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FastCallAttr>::Type>
+from_python<mx::FastCallAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareReductionInitKind>(mx::OMPDeclareReductionInitKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExportDecl>::Type>
+from_python<mx::ExportDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeCastKind>(mx::ObjCBridgeCastKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExclusiveTrylockFunctionAttr>::Type>
+from_python<mx::ExclusiveTrylockFunctionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCImplementationControl>(mx::ObjCImplementationControl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EmptyDecl>::Type>
+from_python<mx::EmptyDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCInstanceTypeFamily>(mx::ObjCInstanceTypeFamily) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExcludeFromExplicitInstantiationAttr>::Type>
+from_python<mx::ExcludeFromExplicitInstantiationAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCLifetime>(mx::ObjCLifetime) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ErrorAttr>::Type>
+from_python<mx::ErrorAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PackExpansionType>(mx::PackExpansionType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroSubstitution>::Type>
+from_python<mx::MacroSubstitution>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodFamily>(mx::ObjCMethodFamily) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumExtensibilityAttr>::Type>
+from_python<mx::EnumExtensibilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCObjectType>(mx::ObjCObjectType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroVAOpt>::Type>
+from_python<mx::MacroVAOpt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PackExpansionType>>(gap::generator<mx::PackExpansionType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnforceTCBAttr>::Type>
+from_python<mx::EnforceTCBAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyQueryKind>(mx::ObjCPropertyQueryKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EmptyTokenTreeNode>::Type>
+from_python<mx::EmptyTokenTreeNode>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCStringFormatFamily>(mx::ObjCStringFormatFamily) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquireHandleAttrSpelling>::Type>
+from_python<mx::AcquireHandleAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PackExpansionType>>(std::optional<mx::PackExpansionType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnableIfAttr>::Type>
+from_python<mx::EnableIfAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCSubstitutionContext>(mx::ObjCSubstitutionContext) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenTokenTreeNode>::Type>
+from_python<mx::TokenTokenTreeNode>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCTypeParamVariance>(mx::ObjCTypeParamVariance) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AddressSpaceAttrSpelling>::Type>
+from_python<mx::AddressSpaceAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OnOffSwitch>(mx::OnOffSwitch) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EmptyBasesAttr>::Type>
+from_python<mx::EmptyBasesAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OnStackType>(mx::OnStackType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ChoiceTokenTreeNode>::Type>
+from_python<mx::ChoiceTokenTreeNode>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPAdjustArgsOpKind>(mx::OpenMPAdjustArgsOpKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DisableTailCallsAttr>::Type>
+from_python<mx::DisableTailCallsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPAtClauseKind>(mx::OpenMPAtClauseKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstitutionTokenTreeNode>::Type>
+from_python<mx::SubstitutionTokenTreeNode>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPAtomicDefaultMemOrderClauseKind>(mx::OpenMPAtomicDefaultMemOrderClauseKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DisableSanitizerInstrumentationAttr>::Type>
+from_python<mx::DisableSanitizerInstrumentationAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPBindClauseKind>(mx::OpenMPBindClauseKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SequenceTokenTreeNode>::Type>
+from_python<mx::SequenceTokenTreeNode>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDefaultmapClauseKind>(mx::OpenMPDefaultmapClauseKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MipsInterruptAttr>::Type>
+from_python<mx::MipsInterruptAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MemberExpr>(mx::MemberExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Mips16Attr>::Type>
+from_python<mx::Mips16Attr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MaterializeTemporaryExpr>(mx::MaterializeTemporaryExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MinVectorWidthAttr>::Type>
+from_python<mx::MinVectorWidthAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MemberExpr>>(gap::generator<mx::MemberExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AMDGPUWavesPerEUAttrSpelling>::Type>
+from_python<mx::AMDGPUWavesPerEUAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDefaultmapClauseModifier>(mx::OpenMPDefaultmapClauseModifier) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MinSizeAttr>::Type>
+from_python<mx::MinSizeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCTypeParamType>(mx::ObjCTypeParamType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ARMInterruptAttrInterruptType>::Type>
+from_python<mx::ARMInterruptAttrInterruptType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDependClauseKind>(mx::OpenMPDependClauseKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MicroMipsAttr>::Type>
+from_python<mx::MicroMipsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCInterfaceType>(mx::ObjCInterfaceType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MaybeUndefAttr>::Type>
+from_python<mx::MaybeUndefAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCTypeParamType>>(gap::generator<mx::ObjCTypeParamType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MayAliasAttr>::Type>
+from_python<mx::MayAliasAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDeviceClauseModifier>(mx::OpenMPDeviceClauseModifier) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MaxFieldAlignmentAttr>::Type>
+from_python<mx::MaxFieldAlignmentAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCTypeParamType>>(std::optional<mx::ObjCTypeParamType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSVtorDispAttr>::Type>
+from_python<mx::MSVtorDispAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MemberExpr>>(std::optional<mx::MemberExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSStructAttr>::Type>
+from_python<mx::MSStructAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDeviceType>(mx::OpenMPDeviceType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSP430InterruptAttr>::Type>
+from_python<mx::MSP430InterruptAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::MemberExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::MemberExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSNoVTableAttr>::Type>
+from_python<mx::MSNoVTableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDistScheduleClauseKind>(mx::OpenMPDistScheduleClauseKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSInheritanceAttr>::Type>
+from_python<mx::MSInheritanceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDoacrossClauseModifier>(mx::OpenMPDoacrossClauseModifier) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSConstexprAttr>::Type>
+from_python<mx::MSConstexprAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPGrainsizeClauseModifier>(mx::OpenMPGrainsizeClauseModifier) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSAllocatorAttr>::Type>
+from_python<mx::MSAllocatorAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPLinearClauseKind>(mx::OpenMPLinearClauseKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MSABIAttr>::Type>
+from_python<mx::MSABIAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPLastprivateModifier>(mx::OpenMPLastprivateModifier) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MIGServerRoutineAttr>::Type>
+from_python<mx::MIGServerRoutineAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXDestructorDecl>(mx::CXXDestructorDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::M68kRTDAttr>::Type>
+from_python<mx::M68kRTDAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ImplicitConceptSpecializationDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ImplicitConceptSpecializationDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::M68kInterruptAttr>::Type>
+from_python<mx::M68kInterruptAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ImagOp>(mx::ir::hl::ImagOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LocksExcludedAttr>::Type>
+from_python<mx::LocksExcludedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::IfOp>(mx::ir::hl::IfOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LockReturnedAttr>::Type>
+from_python<mx::LockReturnedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDestructorDecl>>(std::optional<mx::CXXDestructorDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LifetimeBoundAttr>::Type>
+from_python<mx::LifetimeBoundAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UMinOp>(mx::ir::llvm::UMinOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LeafAttr>::Type>
+from_python<mx::LeafAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDestructorDecl>>(gap::generator<mx::CXXDestructorDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LayoutVersionAttr>::Type>
+from_python<mx::LayoutVersionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UMaxOp>>(std::optional<mx::ir::llvm::UMaxOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LTOVisibilityPublicAttr>::Type>
+from_python<mx::LTOVisibilityPublicAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::IfOp>>(std::optional<mx::ir::hl::IfOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InternalLinkageAttr>::Type>
+from_python<mx::InternalLinkageAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmStreamingAttr>>(gap::generator<mx::ArmStreamingAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IntelOclBiccAttr>::Type>
+from_python<mx::IntelOclBiccAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Macro>>(std::optional<mx::Macro>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InitPriorityAttr>::Type>
+from_python<mx::InitPriorityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXNewExpr>>(std::optional<mx::CXXNewExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InheritableParamAttr>::Type>
+from_python<mx::InheritableParamAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OptimizeNoneAttr>>(std::optional<mx::OptimizeNoneAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CarriesDependencyAttr>::Type>
+from_python<mx::CarriesDependencyAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXNewExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXNewExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFConsumedAttr>::Type>
+from_python<mx::CFConsumedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ImagOp>>(std::optional<mx::ir::hl::ImagOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnnotateAttr>::Type>
+from_python<mx::AnnotateAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Reference>(mx::Reference) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UseHandleAttr>::Type>
+from_python<mx::UseHandleAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UMinOp>>(std::optional<mx::ir::llvm::UMinOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReleaseHandleAttr>::Type>
+from_python<mx::ReleaseHandleAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmStreamingAttr>>(std::optional<mx::ArmStreamingAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PassObjectSizeAttr>::Type>
+from_python<mx::PassObjectSizeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SourceLocExpr>(mx::SourceLocExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParameterABIAttr>::Type>
+from_python<mx::ParameterABIAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SubstNonTypeTemplateParmPackExpr>>(gap::generator<mx::SubstNonTypeTemplateParmPackExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftIndirectResultAttr>::Type>
+from_python<mx::SwiftIndirectResultAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXDestructorDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXDestructorDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<QualifiedNameRenderOptions>::Type>
+from_python<QualifiedNameRenderOptions>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReferenceKind>(mx::ReferenceKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftErrorResultAttr>::Type>
+from_python<mx::SwiftErrorResultAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ImplicitCastOp>(mx::ir::hl::ImplicitCastOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftContextAttr>::Type>
+from_python<mx::SwiftContextAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ImplicitParamDecl>(mx::ImplicitParamDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SwiftAsyncContextAttr>::Type>
+from_python<mx::SwiftAsyncContextAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BuiltinReferenceKind>(mx::BuiltinReferenceKind) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OSConsumedAttr>::Type>
+from_python<mx::OSConsumedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UMulWithOverflowOp>(mx::ir::llvm::UMulWithOverflowOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NonNullAttr>::Type>
+from_python<mx::NonNullAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ImplicitCastOp>>(std::optional<mx::ir::hl::ImplicitCastOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NSConsumedAttr>::Type>
+from_python<mx::NSConsumedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImplicitParamDecl>>(gap::generator<mx::ImplicitParamDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IFuncAttr>::Type>
+from_python<mx::IFuncAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UMulWithOverflowOp>>(std::optional<mx::ir::llvm::UMulWithOverflowOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CalledOnceAttr>::Type>
+from_python<mx::CalledOnceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLKernelAttr>>(gap::generator<mx::OpenCLKernelAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinAliasAttr>::Type>
+from_python<mx::BuiltinAliasAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::string_view>(std::string_view) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateTypeParmType>::Type>
+from_python<mx::TemplateTypeParmType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstNonTypeTemplateParmPackExpr>>(std::optional<mx::SubstNonTypeTemplateParmPackExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateTypeParmDecl>::Type>
+from_python<mx::TemplateTypeParmDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnaryTransformType>>(gap::generator<mx::UnaryTransformType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateSpecializationType>::Type>
+from_python<mx::TemplateSpecializationType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinReferenceKind>>(std::optional<mx::BuiltinReferenceKind>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TagType>::Type>
+from_python<mx::TagType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::IndirectCallOp>(mx::ir::hl::IndirectCallOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RecordType>::Type>
+from_python<mx::RecordType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UShlSatOp>(mx::ir::llvm::UShlSatOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EnumType>::Type>
+from_python<mx::EnumType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmPreservesAttr>>(gap::generator<mx::ArmPreservesAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstTemplateTypeParmType>::Type>
+from_python<mx::SubstTemplateTypeParmType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SubstNonTypeTemplateParmPackExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::SubstNonTypeTemplateParmPackExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SubstTemplateTypeParmPackType>::Type>
+from_python<mx::SubstTemplateTypeParmPackType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::string>(std::string) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReferenceType>::Type>
+from_python<mx::ReferenceType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UShlSatOp>>(std::optional<mx::ir::llvm::UShlSatOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RValueReferenceType>::Type>
+from_python<mx::RValueReferenceType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::IndirectCallOp>>(std::optional<mx::ir::hl::IndirectCallOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::LValueReferenceType>::Type>
+from_python<mx::LValueReferenceType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImplicitParamDecl>>(std::optional<mx::ImplicitParamDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::QualifiedType>::Type>
+from_python<mx::QualifiedType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnaryTransformType>>(std::optional<mx::UnaryTransformType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PointerType>::Type>
+from_python<mx::PointerType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CompoundLiteralExpr>>(gap::generator<mx::CompoundLiteralExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PipeType>::Type>
+from_python<mx::PipeType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLKernelAttr>>(std::optional<mx::OpenCLKernelAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParenType>::Type>
+from_python<mx::ParenType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ImplicitParamDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ImplicitParamDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PackExpansionType>::Type>
+from_python<mx::PackExpansionType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::USubSatOp>(mx::ir::llvm::USubSatOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCTypeParamType>::Type>
+from_python<mx::ObjCTypeParamType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXConstructExpr>(mx::CXXConstructExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCObjectType>::Type>
+from_python<mx::ObjCObjectType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::IndirectGotoStmtOp>(mx::ir::hl::IndirectGotoStmtOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCTypeParamDecl>::Type>
+from_python<mx::ObjCTypeParamDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXConstructExpr>>(std::optional<mx::CXXConstructExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCInterfaceType>::Type>
+from_python<mx::ObjCInterfaceType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::USubSatOp>>(std::optional<mx::ir::llvm::USubSatOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCObjectPointerType>::Type>
+from_python<mx::ObjCObjectPointerType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmPreservesAttr>>(std::optional<mx::ArmPreservesAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MemberPointerType>::Type>
+from_python<mx::MemberPointerType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::IndirectGotoStmtOp>>(std::optional<mx::ir::hl::IndirectGotoStmtOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MatrixType>::Type>
+from_python<mx::MatrixType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXConstructExpr>>(gap::generator<mx::CXXConstructExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentSizedMatrixType>::Type>
+from_python<mx::DependentSizedMatrixType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Type>(mx::Type) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstantMatrixType>::Type>
+from_python<mx::ConstantMatrixType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CompoundLiteralExpr>>(std::optional<mx::CompoundLiteralExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroQualifiedType>::Type>
+from_python<mx::MacroQualifiedType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::InitListExprOp>(mx::ir::hl::InitListExprOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ComplexType>::Type>
+from_python<mx::ComplexType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedTypeId>(PackedTypeId) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InjectedClassNameType>::Type>
+from_python<mx::InjectedClassNameType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::USubWithOverflowOp>(mx::ir::llvm::USubWithOverflowOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionType>::Type>
+from_python<mx::FunctionType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LambdaCaptureDefault>>(std::optional<mx::LambdaCaptureDefault>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionProtoType>::Type>
+from_python<mx::FunctionProtoType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CompoundLiteralExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CompoundLiteralExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionNoProtoType>::Type>
+from_python<mx::FunctionNoProtoType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::USubWithOverflowOp>>(std::optional<mx::ir::llvm::USubWithOverflowOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentVectorType>::Type>
+from_python<mx::DependentVectorType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::InitListExprOp>>(std::optional<mx::ir::hl::InitListExprOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentSizedExtVectorType>::Type>
+from_python<mx::DependentSizedExtVectorType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLIntelReqdSubGroupSizeAttr>>(gap::generator<mx::OpenCLIntelReqdSubGroupSizeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentBitIntType>::Type>
+from_python<mx::DependentBitIntType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Type>>(gap::generator<mx::Type>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DependentAddressSpaceType>::Type>
+from_python<mx::DependentAddressSpaceType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<std::vector<mx::NamedDecl>>>(std::optional<std::vector<mx::NamedDecl>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeducedType>::Type>
+from_python<mx::DeducedType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypedefType>>(gap::generator<mx::TypedefType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeducedTemplateSpecializationType>::Type>
+from_python<mx::DeducedTemplateSpecializationType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<uint32_t>>(std::optional<uint32_t>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AutoType>::Type>
+from_python<mx::AutoType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LNotOp>(mx::ir::hl::LNotOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConceptDecl>::Type>
+from_python<mx::ConceptDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmOutAttr>(mx::ArmOutAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Attr>::Type>
+from_python<mx::Attr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::InitializedConstantOp>(mx::ir::hl::InitializedConstantOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReferenceKind>::Type>
+from_python<mx::ReferenceKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPAddOp>(mx::ir::llvm::VPAddOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Type>::Type>
+from_python<mx::Type>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmOutAttr>>(gap::generator<mx::ArmOutAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::vector<std::variant<mx::TokenRange, mx::TokenTreeNode>>>::Type>
+from_python<std::vector<std::variant<mx::TokenRange, mx::TokenTreeNode>>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXConstructExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXConstructExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::StmtKind>>::Type>
+from_python<std::span<const mx::StmtKind>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPAShrOp>(mx::ir::llvm::VPAShrOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::span<const mx::DeclKind>>::Type>
+from_python<std::span<const mx::DeclKind>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::InitializedConstantOp>>(std::optional<mx::ir::hl::InitializedConstantOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FieldDecl>::Type>
+from_python<mx::FieldDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypedefType>>(std::optional<mx::TypedefType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclaratorDecl>::Type>
+from_python<mx::DeclaratorDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPAShrOp>>(std::optional<mx::ir::llvm::VPAShrOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ValueDecl>::Type>
+from_python<mx::ValueDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NonTypeTemplateParmDecl>(mx::NonTypeTemplateParmDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NamedDecl>::Type>
+from_python<mx::NamedDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Type>>(std::optional<mx::Type>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VarDecl>::Type>
+from_python<mx::VarDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NonTypeTemplateParmDecl>>(gap::generator<mx::NonTypeTemplateParmDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VarTemplateDecl>::Type>
+from_python<mx::VarTemplateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLIntelReqdSubGroupSizeAttr>>(std::optional<mx::OpenCLIntelReqdSubGroupSizeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RedeclarableTemplateDecl>::Type>
+from_python<mx::RedeclarableTemplateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LNotOp>>(std::optional<mx::ir::hl::LNotOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateDecl>::Type>
+from_python<mx::TemplateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmOutAttr>>(std::optional<mx::ArmOutAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Expr>::Type>
+from_python<mx::Expr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPAndOp>(mx::ir::llvm::VPAndOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ValueStmt>::Type>
+from_python<mx::ValueStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NonTypeTemplateParmDecl>>(std::optional<mx::NonTypeTemplateParmDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyRefExpr>::Type>
+from_python<mx::ObjCPropertyRefExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPAddOp>>(std::optional<mx::ir::llvm::VPAddOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCInterfaceDecl>::Type>
+from_python<mx::ObjCInterfaceDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeOfType>(mx::TypeOfType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCContainerDecl>::Type>
+from_python<mx::ObjCContainerDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LabelDeclOp>(mx::ir::hl::LabelDeclOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodDecl>::Type>
+from_python<mx::ObjCMethodDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SEHLeaveStmt>(mx::SEHLeaveStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyDecl>::Type>
+from_python<mx::ObjCPropertyDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeOfType>>(gap::generator<mx::TypeOfType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCIvarDecl>::Type>
+from_python<mx::ObjCIvarDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::NonTypeTemplateParmDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::NonTypeTemplateParmDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ImplicitParamDecl>::Type>
+from_python<mx::ImplicitParamDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LabelDeclOp>>(std::optional<mx::ir::hl::LabelDeclOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParmVarDecl>::Type>
+from_python<mx::ParmVarDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCSubclassingRestrictedAttr>(mx::ObjCSubclassingRestrictedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCProtocolDecl>::Type>
+from_python<mx::ObjCProtocolDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCSubclassingRestrictedAttr>>(gap::generator<mx::ObjCSubclassingRestrictedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCImplementationDecl>::Type>
+from_python<mx::ObjCImplementationDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParmVarDecl>(mx::ParmVarDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCImplDecl>::Type>
+from_python<mx::ObjCImplDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CastExpr>(mx::CastExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyImplDecl>::Type>
+from_python<mx::ObjCPropertyImplDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParmVarDecl>>(std::optional<mx::ParmVarDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCCategoryDecl>::Type>
+from_python<mx::ObjCCategoryDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ChooseExpr>>(gap::generator<mx::ChooseExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCCategoryImplDecl>::Type>
+from_python<mx::ObjCCategoryImplDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParmVarDecl>>(gap::generator<mx::ParmVarDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VariableArrayType>::Type>
+from_python<mx::VariableArrayType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateArgument>(mx::TemplateArgument) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArrayType>::Type>
+from_python<mx::ArrayType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmMveStrictPolymorphismAttr>(mx::ArmMveStrictPolymorphismAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IndirectFieldDecl>::Type>
+from_python<mx::IndirectFieldDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeOfType>>(std::optional<mx::TypeOfType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXRecordDecl>::Type>
+from_python<mx::CXXRecordDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmMveStrictPolymorphismAttr>>(gap::generator<mx::ArmMveStrictPolymorphismAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RecordDecl>::Type>
+from_python<mx::RecordDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::MinusOp>(mx::ir::hl::MinusOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TagDecl>::Type>
+from_python<mx::TagDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LabelStmtOp>(mx::ir::hl::LabelStmtOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeDecl>::Type>
+from_python<mx::TypeDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPAndOp>>(std::optional<mx::ir::llvm::VPAndOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypedefNameDecl>::Type>
+from_python<mx::TypedefNameDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LabelStmtOp>>(std::optional<mx::ir::hl::LabelStmtOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXConstructorDecl>::Type>
+from_python<mx::CXXConstructorDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedTemplateArgumentId>(PackedTemplateArgumentId) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXMethodDecl>::Type>
+from_python<mx::CXXMethodDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateArgument>>(gap::generator<mx::TemplateArgument>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionDecl>::Type>
+from_python<mx::FunctionDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCSubclassingRestrictedAttr>>(std::optional<mx::ObjCSubclassingRestrictedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FunctionTemplateDecl>::Type>
+from_python<mx::FunctionTemplateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ChooseExpr>>(std::optional<mx::ChooseExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FriendDecl>::Type>
+from_python<mx::FriendDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ChooseExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ChooseExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ClassTemplateDecl>::Type>
+from_python<mx::ClassTemplateDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmMveStrictPolymorphismAttr>>(std::optional<mx::ArmMveStrictPolymorphismAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXXDestructorDecl>::Type>
+from_python<mx::CXXDestructorDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ParmVarDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ParmVarDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DefineMacroDirective>::Type>
+from_python<mx::DefineMacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::MinusOp>>(std::optional<mx::ir::hl::MinusOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroDirective>::Type>
+from_python<mx::MacroDirective>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFAddOp>(mx::ir::llvm::VPFAddOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ExternalSourceSymbolAttr>::Type>
+from_python<mx::ExternalSourceSymbolAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeOfExprType>(mx::TypeOfExprType) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::InheritableAttr>::Type>
+from_python<mx::InheritableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeOfExprType>>(gap::generator<mx::TypeOfExprType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignValueAttr>::Type>
+from_python<mx::AlignValueAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFAddOp>>(std::optional<mx::ir::llvm::VPFAddOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AliasAttr>::Type>
+from_python<mx::AliasAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateArgument>>(std::optional<mx::TemplateArgument>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AbiTagAttr>::Type>
+from_python<mx::AbiTagAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXDependentScopeMemberExpr>(mx::CXXDependentScopeMemberExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeAttr>::Type>
+from_python<mx::TypeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXInheritedCtorInitExpr>>(gap::generator<mx::CXXInheritedCtorInitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SPtrAttr>::Type>
+from_python<mx::SPtrAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::MulFOp>(mx::ir::hl::MulFOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Ptr64Attr>::Type>
+from_python<mx::Ptr64Attr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRootClassAttr>(mx::ObjCRootClassAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Ptr32Attr>::Type>
+from_python<mx::Ptr32Attr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::MulFAssignOp>(mx::ir::hl::MulFAssignOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLPrivateAddressSpaceAttr>::Type>
+from_python<mx::OpenCLPrivateAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRootClassAttr>>(gap::generator<mx::ObjCRootClassAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLLocalAddressSpaceAttr>::Type>
+from_python<mx::OpenCLLocalAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeOfExprType>>(std::optional<mx::TypeOfExprType>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalHostAddressSpaceAttr>::Type>
+from_python<mx::OpenCLGlobalHostAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::MulFAssignOp>>(std::optional<mx::ir::hl::MulFAssignOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalDeviceAddressSpaceAttr>::Type>
+from_python<mx::OpenCLGlobalDeviceAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmInOutAttr>(mx::ArmInOutAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGlobalAddressSpaceAttr>::Type>
+from_python<mx::OpenCLGlobalAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmInOutAttr>>(gap::generator<mx::ArmInOutAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLGenericAddressSpaceAttr>::Type>
+from_python<mx::OpenCLGenericAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFDivOp>(mx::ir::llvm::VPFDivOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenCLConstantAddressSpaceAttr>::Type>
+from_python<mx::OpenCLConstantAddressSpaceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXInheritedCtorInitExpr>>(std::optional<mx::CXXInheritedCtorInitExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCKindOfAttr>::Type>
+from_python<mx::ObjCKindOfAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFDivOp>>(std::optional<mx::ir::llvm::VPFDivOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCInertUnsafeUnretainedAttr>::Type>
+from_python<mx::ObjCInertUnsafeUnretainedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SubstNonTypeTemplateParmExpr>>(gap::generator<mx::SubstNonTypeTemplateParmExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MethodRefFlags>::Type>
+from_python<mx::MethodRefFlags>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXInheritedCtorInitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXInheritedCtorInitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclCategory>::Type>
+from_python<mx::DeclCategory>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRootClassAttr>>(std::optional<mx::ObjCRootClassAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnoseIfAttr>::Type>
+from_python<mx::DiagnoseIfAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::MulFOp>>(std::optional<mx::ir::hl::MulFOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ModifiableType>::Type>
+from_python<mx::ModifiableType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Reference>>(gap::generator<mx::Reference>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PseudoKind>::Type>
+from_python<mx::PseudoKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateParameterList>(mx::TemplateParameterList) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DiagnoseAsBuiltinAttr>::Type>
+from_python<mx::DiagnoseAsBuiltinAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmInOutAttr>>(std::optional<mx::ArmInOutAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MultiVersionKind>::Type>
+from_python<mx::MultiVersionKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SEHTryStmt>(mx::SEHTryStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::EntityCategory>::Type>
+from_python<mx::EntityCategory>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReturnStmt>(mx::ReturnStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DestructorAttr>::Type>
+from_python<mx::DestructorAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SEHTryStmt>>(gap::generator<mx::SEHTryStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NameKind>::Type>
+from_python<mx::NameKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstNonTypeTemplateParmExpr>>(std::optional<mx::SubstNonTypeTemplateParmExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NeedExtraManglingDecl>::Type>
+from_python<mx::NeedExtraManglingDecl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFMulAddOp>(mx::ir::llvm::VPFMulAddOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeprecatedAttr>::Type>
+from_python<mx::DeprecatedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFMulAddOp>>(std::optional<mx::ir::llvm::VPFMulAddOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NestedNameSpecifierDependence>::Type>
+from_python<mx::NestedNameSpecifierDependence>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedTemplateParameterListId>(PackedTemplateParameterListId) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::MacroKind>::Type>
+from_python<mx::MacroKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::MulIOp>(mx::ir::hl::MulIOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DeclOrStmtAttr>::Type>
+from_python<mx::DeclOrStmtAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Attr>>(std::optional<mx::Attr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NonOdrUseReason>::Type>
+from_python<mx::NonOdrUseReason>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::MulIAssignOp>(mx::ir::hl::MulIAssignOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinReferenceKind>::Type>
+from_python<mx::BuiltinReferenceKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateParameterList>>(gap::generator<mx::TemplateParameterList>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlwaysInlineAttr>::Type>
+from_python<mx::AlwaysInlineAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SubstNonTypeTemplateParmExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::SubstNonTypeTemplateParmExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NonceObjCInterface>::Type>
+from_python<mx::NonceObjCInterface>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CharacterLiteral>(mx::CharacterLiteral) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<std::optional<mx::TemplateParameterList>>::Type>
+from_python<std::optional<mx::TemplateParameterList>>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ImplicitCastExpr>(mx::ImplicitCastExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NullabilityKind>::Type>
+from_python<mx::NullabilityKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::MulIAssignOp>>(std::optional<mx::ir::hl::MulIAssignOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SuppressAttr>::Type>
+from_python<mx::SuppressAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CharacterLiteral>>(gap::generator<mx::CharacterLiteral>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OMPDeclareReductionInitKind>::Type>
+from_python<mx::OMPDeclareReductionInitKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCReturnsInnerPointerAttr>(mx::ObjCReturnsInnerPointerAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoMergeAttr>::Type>
+from_python<mx::NoMergeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRequiresPropertyDefsAttr>(mx::ObjCRequiresPropertyDefsAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCBridgeCastKind>::Type>
+from_python<mx::ObjCBridgeCastKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCReturnsInnerPointerAttr>>(gap::generator<mx::ObjCReturnsInnerPointerAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::NoInlineAttr>::Type>
+from_python<mx::NoInlineAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SEHTryStmt>>(std::optional<mx::SEHTryStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCImplementationControl>::Type>
+from_python<mx::ObjCImplementationControl>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Compilation>>(std::optional<mx::Compilation>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenTreeNodeKind>::Type>
+from_python<mx::TokenTreeNodeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmInAttr>(mx::ArmInAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCInstanceTypeFamily>::Type>
+from_python<mx::ObjCInstanceTypeFamily>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AddressSpaceAttr>(mx::AddressSpaceAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenKind>::Type>
+from_python<mx::TokenKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmInAttr>>(gap::generator<mx::ArmInAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLImportStaticLocalAttr>::Type>
+from_python<mx::DLLImportStaticLocalAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SEHTryStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::SEHTryStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCLifetime>::Type>
+from_python<mx::ObjCLifetime>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::NotOp>(mx::ir::hl::NotOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TokenCategory>::Type>
+from_python<mx::TokenCategory>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateParameterList>>(std::optional<mx::TemplateParameterList>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLImportAttr>::Type>
+from_python<mx::DLLImportAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFMulOp>(mx::ir::llvm::VPFMulOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCMethodFamily>::Type>
+from_python<mx::ObjCMethodFamily>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Decl>>(gap::generator<mx::Decl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IndexStatus>::Type>
+from_python<mx::IndexStatus>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFMulOp>>(std::optional<mx::ir::llvm::VPFMulOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLExportStaticLocalAttr>::Type>
+from_python<mx::DLLExportStaticLocalAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::MulIOp>>(std::optional<mx::ir::hl::MulIOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCPropertyQueryKind>::Type>
+from_python<mx::ObjCPropertyQueryKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CharacterLiteral>>(std::optional<mx::CharacterLiteral>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::IncludePathLocation>::Type>
+from_python<mx::IncludePathLocation>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::variant<mx::Macro, mx::Token, mx::Fragment>>>(gap::generator<std::variant<mx::Macro, mx::Token, mx::Fragment>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCStringFormatFamily>::Type>
+from_python<mx::ObjCStringFormatFamily>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCReturnsInnerPointerAttr>>(std::optional<mx::ObjCReturnsInnerPointerAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PathKind>::Type>
+from_python<mx::PathKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CharacterLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::CharacterLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::DLLExportAttr>::Type>
+from_python<mx::DLLExportAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXDeleteExpr>(mx::CXXDeleteExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCSubstitutionContext>::Type>
+from_python<mx::ObjCSubstitutionContext>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXFoldExpr>>(gap::generator<mx::CXXFoldExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::FileType>::Type>
+from_python<mx::FileType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmInAttr>>(std::optional<mx::ArmInAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CountedByAttr>::Type>
+from_python<mx::CountedByAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFNegOp>(mx::ir::llvm::VPFNegOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ObjCTypeParamVariance>::Type>
+from_python<mx::ObjCTypeParamVariance>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::NotOp>>(std::optional<mx::ir::hl::NotOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CompilerName>::Type>
+from_python<mx::CompilerName>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFNegOp>>(std::optional<mx::ir::llvm::VPFNegOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroWrapperAttr>::Type>
+from_python<mx::CoroWrapperAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRequiresSuperAttr>(mx::ObjCRequiresSuperAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OnOffSwitch>::Type>
+from_python<mx::OnOffSwitch>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXBaseSpecifier>(mx::CXXBaseSpecifier) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TargetLanguage>::Type>
+from_python<mx::TargetLanguage>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCPreciseLifetimeAttr>(mx::ObjCPreciseLifetimeAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OnStackType>::Type>
+from_python<mx::OnStackType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRequiresSuperAttr>>(gap::generator<mx::ObjCRequiresSuperAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroReturnTypeAttr>::Type>
+from_python<mx::CoroReturnTypeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXFoldExpr>>(std::optional<mx::CXXFoldExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AcquireCapabilityAttrSpelling>::Type>
+from_python<mx::AcquireCapabilityAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::NullStmtOp>(mx::ir::hl::NullStmtOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPAdjustArgsOpKind>::Type>
+from_python<mx::OpenMPAdjustArgsOpKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TokenTree>(mx::TokenTree) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroOnlyDestroyWhenCompleteAttr>::Type>
+from_python<mx::CoroOnlyDestroyWhenCompleteAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StmtExpr>(mx::StmtExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPAtClauseKind>::Type>
+from_python<mx::OpenMPAtClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<uint64_t>>(std::optional<uint64_t>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroLifetimeBoundAttr>::Type>
+from_python<mx::CoroLifetimeBoundAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SizeOfPackExpr>(mx::SizeOfPackExpr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPAtomicDefaultMemOrderClauseKind>::Type>
+from_python<mx::OpenMPAtomicDefaultMemOrderClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StmtExpr>>(gap::generator<mx::StmtExpr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPBindClauseKind>::Type>
+from_python<mx::OpenMPBindClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::NullStmtOp>>(std::optional<mx::ir::hl::NullStmtOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CoroDisableLifetimeBoundAttr>::Type>
+from_python<mx::CoroDisableLifetimeBoundAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AnnotateTypeAttr>(mx::AnnotateTypeAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDefaultmapClauseKind>::Type>
+from_python<mx::OpenMPDefaultmapClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXFoldExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXFoldExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConvergentAttr>::Type>
+from_python<mx::ConvergentAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFPToSIOp>(mx::ir::llvm::VPFPToSIOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDefaultmapClauseModifier>::Type>
+from_python<mx::OpenMPDefaultmapClauseModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyFuncrefAttr>(mx::WebAssemblyFuncrefAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableSetOnReadAttr>::Type>
+from_python<mx::ConsumableSetOnReadAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFPExtOp>(mx::ir::llvm::VPFPExtOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDependClauseKind>::Type>
+from_python<mx::OpenMPDependClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnnotateTypeAttr>>(gap::generator<mx::AnnotateTypeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDeviceClauseModifier>::Type>
+from_python<mx::OpenMPDeviceClauseModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCInterfaceDecl>>(std::optional<mx::ObjCInterfaceDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAutoCastAttr>::Type>
+from_python<mx::ConsumableAutoCastAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SEHExceptStmt>(mx::SEHExceptStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDeviceType>::Type>
+from_python<mx::OpenMPDeviceType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::OffsetOfExprOp>(mx::ir::hl::OffsetOfExprOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConsumableAttr>::Type>
+from_python<mx::ConsumableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFPExtOp>>(std::optional<mx::ir::llvm::VPFPExtOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDistScheduleClauseKind>::Type>
+from_python<mx::OpenMPDistScheduleClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedCXXBaseSpecifierId>(PackedCXXBaseSpecifierId) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstructorAttr>::Type>
+from_python<mx::ConstructorAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::OpaqueValueExprOp>(mx::ir::hl::OpaqueValueExprOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPDoacrossClauseModifier>::Type>
+from_python<mx::OpenMPDoacrossClauseModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXBaseSpecifier>>(gap::generator<mx::CXXBaseSpecifier>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPGrainsizeClauseModifier>::Type>
+from_python<mx::OpenMPGrainsizeClauseModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SEHExceptStmt>>(gap::generator<mx::SEHExceptStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstInitAttr>::Type>
+from_python<mx::ConstInitAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCInterfaceDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCInterfaceDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPLastprivateModifier>::Type>
+from_python<mx::OpenMPLastprivateModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::OffsetOfExprOp>>(std::optional<mx::ir::hl::OffsetOfExprOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ConstAttr>::Type>
+from_python<mx::ConstAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MipsLongCallAttr>>(std::optional<mx::MipsLongCallAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPLinearClauseKind>::Type>
+from_python<mx::OpenMPLinearClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTaskLoopSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTaskLoopSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CommonAttr>::Type>
+from_python<mx::CommonAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HIPManagedAttr>>(gap::generator<mx::HIPManagedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPMapClauseKind>::Type>
+from_python<mx::OpenMPMapClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MipsInterruptAttr>>(gap::generator<mx::MipsInterruptAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPMapModifierKind>::Type>
+from_python<mx::OpenMPMapModifierKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetExitDataDirective>>(gap::generator<mx::OMPTargetExitDataDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ColdAttr>::Type>
+from_python<mx::ColdAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HIPManagedAttr>>(std::optional<mx::HIPManagedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPMotionModifierKind>::Type>
+from_python<mx::OpenMPMotionModifierKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ClassTemplateSpecializationDecl>>(gap::generator<mx::ClassTemplateSpecializationDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeSegAttr>::Type>
+from_python<mx::CodeSegAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MipsInterruptAttr>>(std::optional<mx::MipsInterruptAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPNumTasksClauseModifier>::Type>
+from_python<mx::OpenMPNumTasksClauseModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetExitDataDirective>>(std::optional<mx::OMPTargetExitDataDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CodeModelAttr>::Type>
+from_python<mx::CodeModelAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetExitDataDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetExitDataDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPOrderClauseKind>::Type>
+from_python<mx::OpenMPOrderClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskLoopDirective>>(gap::generator<mx::OMPTaskLoopDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPOrderClauseModifier>::Type>
+from_python<mx::OpenMPOrderClauseModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GuardedVarAttr>>(gap::generator<mx::GuardedVarAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CmseNSEntryAttr>::Type>
+from_python<mx::CmseNSEntryAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ClassTemplateSpecializationDecl>>(std::optional<mx::ClassTemplateSpecializationDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPReductionClauseModifier>::Type>
+from_python<mx::OpenMPReductionClauseModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ClassTemplateSpecializationDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ClassTemplateSpecializationDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CleanupAttr>::Type>
+from_python<mx::CleanupAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Mips16Attr>>(gap::generator<mx::Mips16Attr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPScheduleClauseKind>::Type>
+from_python<mx::OpenMPScheduleClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskLoopDirective>>(std::optional<mx::OMPTaskLoopDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CapturedRecordAttr>::Type>
+from_python<mx::CapturedRecordAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTaskLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTaskLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPScheduleClauseModifier>::Type>
+from_python<mx::OpenMPScheduleClauseModifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GuardedVarAttr>>(std::optional<mx::GuardedVarAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OpenMPSeverityClauseKind>::Type>
+from_python<mx::OpenMPSeverityClauseKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Mips16Attr>>(std::optional<mx::Mips16Attr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CapabilityAttr>::Type>
+from_python<mx::CapabilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetEnterDataDirective>>(gap::generator<mx::OMPTargetEnterDataDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadedOperatorKind>::Type>
+from_python<mx::OverloadedOperatorKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GuardedByAttr>(mx::GuardedByAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CallbackAttr>::Type>
+from_python<mx::CallbackAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GuardedByAttr>>(gap::generator<mx::GuardedByAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::OverloadsShown>::Type>
+from_python<mx::OverloadsShown>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MinVectorWidthAttr>(mx::MinVectorWidthAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CallableWhenAttr>::Type>
+from_python<mx::CallableWhenAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MinVectorWidthAttr>>(gap::generator<mx::MinVectorWidthAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParameterABI>::Type>
+from_python<mx::ParameterABI>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetEnterDataDirective>>(std::optional<mx::OMPTargetEnterDataDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ParenLocsOffsets>::Type>
+from_python<mx::ParenLocsOffsets>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetEnterDataDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetEnterDataDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CXX11NoReturnAttr>::Type>
+from_python<mx::CXX11NoReturnAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GuardedByAttr>>(std::optional<mx::GuardedByAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaFPKind>::Type>
+from_python<mx::PragmaFPKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ClassTemplatePartialSpecializationDecl>>(gap::generator<mx::ClassTemplatePartialSpecializationDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDASharedAttr>::Type>
+from_python<mx::CUDASharedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsGenericLoopDirective>>(gap::generator<mx::OMPTargetTeamsGenericLoopDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaFloatControlKind>::Type>
+from_python<mx::PragmaFloatControlKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MinVectorWidthAttr>>(std::optional<mx::MinVectorWidthAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDALaunchBoundsAttr>::Type>
+from_python<mx::CUDALaunchBoundsAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ClassTemplatePartialSpecializationDecl>>(std::optional<mx::ClassTemplatePartialSpecializationDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaMSCommentKind>::Type>
+from_python<mx::PragmaMSCommentKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsGenericLoopDirective>>(std::optional<mx::OMPTargetTeamsGenericLoopDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaMSPointersToMembersKind>::Type>
+from_python<mx::PragmaMSPointersToMembersKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GNUInlineAttr>(mx::GNUInlineAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAInvalidTargetAttr>::Type>
+from_python<mx::CUDAInvalidTargetAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GNUInlineAttr>>(gap::generator<mx::GNUInlineAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaMSStructKind>::Type>
+from_python<mx::PragmaMSStructKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ClassTemplatePartialSpecializationDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ClassTemplatePartialSpecializationDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAHostAttr>::Type>
+from_python<mx::CUDAHostAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetTeamsGenericLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetTeamsGenericLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PragmaSectionFlag>::Type>
+from_python<mx::PragmaSectionFlag>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MinSizeAttr>(mx::MinSizeAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAGlobalAttr>::Type>
+from_python<mx::CUDAGlobalAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MinSizeAttr>>(gap::generator<mx::MinSizeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::PredefinedIdentKind>::Type>
+from_python<mx::PredefinedIdentKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetDirective>(mx::OMPTargetDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Qualified>::Type>
+from_python<mx::Qualified>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GNUInlineAttr>>(std::optional<mx::GNUInlineAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceBuiltinTextureTypeAttr>::Type>
+from_python<mx::CUDADeviceBuiltinTextureTypeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPSingleDirective>(mx::OMPSingleDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RangeExprOffset>::Type>
+from_python<mx::RangeExprOffset>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetDirective>>(gap::generator<mx::OMPTargetDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceBuiltinSurfaceTypeAttr>::Type>
+from_python<mx::CUDADeviceBuiltinSurfaceTypeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MinSizeAttr>>(std::optional<mx::MinSizeAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RangeLocOffset>::Type>
+from_python<mx::RangeLocOffset>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetDirective>>(std::optional<mx::OMPTargetDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDADeviceAttr>::Type>
+from_python<mx::CUDADeviceAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionReturnThunksAttr>(mx::FunctionReturnThunksAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RecordArgPassingKind>::Type>
+from_python<mx::RecordArgPassingKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FlagEnumAttr>(mx::FlagEnumAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::RefQualifierKind>::Type>
+from_python<mx::RefQualifierKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionReturnThunksAttr>>(gap::generator<mx::FunctionReturnThunksAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CUDAConstantAttr>::Type>
+from_python<mx::CUDAConstantAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReservedIdentifierStatus>::Type>
+from_python<mx::ReservedIdentifierStatus>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDistributeSimdDirective>(mx::OMPTargetTeamsDistributeSimdDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CPUSpecificAttr>::Type>
+from_python<mx::CPUSpecificAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDistributeParallelForDirective>(mx::OMPTargetTeamsDistributeParallelForDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ReservedLiteralSuffixIdStatus>::Type>
+from_python<mx::ReservedLiteralSuffixIdStatus>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDistributeSimdDirective>>(gap::generator<mx::OMPTargetTeamsDistributeSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CPUDispatchAttr>::Type>
+from_python<mx::CPUDispatchAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypedefDecl>(mx::TypedefDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SFINAEResponse>::Type>
+from_python<mx::SFINAEResponse>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BuiltinTemplateDecl>(mx::BuiltinTemplateDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SYCLMajorVersion>::Type>
+from_python<mx::SYCLMajorVersion>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MicroMipsAttr>(mx::MicroMipsAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFUnknownTransferAttr>::Type>
+from_python<mx::CFUnknownTransferAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypedefDecl>>(gap::generator<mx::TypedefDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SanitizerOrdinal>::Type>
+from_python<mx::SanitizerOrdinal>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MayAliasAttr>(mx::MayAliasAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFReturnsRetainedAttr>::Type>
+from_python<mx::CFReturnsRetainedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MicroMipsAttr>>(gap::generator<mx::MicroMipsAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SelectorLocationsKind>::Type>
+from_python<mx::SelectorLocationsKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionReturnThunksAttr>>(std::optional<mx::FunctionReturnThunksAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFReturnsNotRetainedAttr>::Type>
+from_python<mx::CFReturnsNotRetainedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDistributeSimdDirective>>(std::optional<mx::OMPTargetTeamsDistributeSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ShaderStage>::Type>
+from_python<mx::ShaderStage>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypedefDecl>>(std::optional<mx::TypedefDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SignReturnAddressKeyKind>::Type>
+from_python<mx::SignReturnAddressKeyKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetTeamsDistributeSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetTeamsDistributeSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFICanonicalJumpTableAttr>::Type>
+from_python<mx::CFICanonicalJumpTableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MicroMipsAttr>>(std::optional<mx::MicroMipsAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SignReturnAddressScopeKind>::Type>
+from_python<mx::SignReturnAddressScopeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TypedefDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TypedefDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFGuardAttr>::Type>
+from_python<mx::CFGuardAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FormatAttr>(mx::FormatAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SignedOverflowBehaviorTy>::Type>
+from_python<mx::SignedOverflowBehaviorTy>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FlattenAttr>(mx::FlattenAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CFAuditedTransferAttr>::Type>
+from_python<mx::CFAuditedTransferAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FormatAttr>>(gap::generator<mx::FormatAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SourceLocIdentKind>::Type>
+from_python<mx::SourceLocIdentKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetDataDirective>(mx::OMPTargetDataDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SpecialMemberFlags>::Type>
+from_python<mx::SpecialMemberFlags>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPSectionsDirective>(mx::OMPSectionsDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::CDeclAttr>::Type>
+from_python<mx::CDeclAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetDataDirective>>(gap::generator<mx::OMPTargetDataDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SpecifierKind>::Type>
+from_python<mx::SpecifierKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MaybeUndefAttr>(mx::MaybeUndefAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::C11NoReturnAttr>::Type>
+from_python<mx::C11NoReturnAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MaxFieldAlignmentAttr>(mx::MaxFieldAlignmentAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StackProtectorMode>::Type>
+from_python<mx::StackProtectorMode>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MaybeUndefAttr>>(gap::generator<mx::MaybeUndefAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BuiltinAttr>::Type>
+from_python<mx::BuiltinAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FormatAttr>>(std::optional<mx::FormatAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StorageClass>::Type>
+from_python<mx::StorageClass>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetDataDirective>>(std::optional<mx::OMPTargetDataDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StorageDuration>::Type>
+from_python<mx::StorageDuration>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetDataDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetDataDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BlocksAttr>::Type>
+from_python<mx::BlocksAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MaybeUndefAttr>>(std::optional<mx::MaybeUndefAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StoredNameKind>::Type>
+from_python<mx::StoredNameKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDistributeParallelForSimdDirective>(mx::OMPTargetTeamsDistributeParallelForSimdDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BTFDeclTagAttr>::Type>
+from_python<mx::BTFDeclTagAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDistributeDirective>(mx::OMPTargetTeamsDistributeDirective) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StoredSpecifierKind>::Type>
+from_python<mx::StoredSpecifierKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDistributeParallelForSimdDirective>>(gap::generator<mx::OMPTargetTeamsDistributeParallelForSimdDirective>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BPFPreserveStaticOffsetAttr>::Type>
+from_python<mx::BPFPreserveStaticOffsetAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeAliasDecl>(mx::TypeAliasDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StrictFlexArraysLevelKind>::Type>
+from_python<mx::StrictFlexArraysLevelKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateTemplateParmDecl>(mx::TemplateTemplateParmDecl) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::StringLiteralKind>::Type>
+from_python<mx::StringLiteralKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeAliasDecl>>(gap::generator<mx::TypeAliasDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::BPFPreserveAccessIndexAttr>::Type>
+from_python<mx::BPFPreserveAccessIndexAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FormatArgAttr>(mx::FormatArgAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SubExpr>::Type>
+from_python<mx::SubExpr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FuncOp>>(std::optional<mx::ir::llvm::FuncOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailableOnlyInDefaultEvalMethodAttr>::Type>
+from_python<mx::AvailableOnlyInDefaultEvalMethodAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AnnotationAttr>>(std::optional<mx::ir::hl::AnnotationAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SubStmt>::Type>
+from_python<mx::SubStmt>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::FormatAttr>(mx::ir::hl::FormatAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AvailabilityAttr>::Type>
+from_python<mx::AvailabilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUWavesPerEUAttr>>(gap::generator<mx::AMDGPUWavesPerEUAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::SyncScope>::Type>
+from_python<mx::SyncScope>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CallableWhenAttr>>(std::optional<mx::CallableWhenAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Syntax>::Type>
+from_python<mx::Syntax>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPAllocateDecl>>(std::optional<mx::OMPAllocateDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AssumptionAttr>::Type>
+from_python<mx::AssumptionAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::FormatAttr>>(std::optional<mx::ir::hl::FormatAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TQ>::Type>
+from_python<mx::TQ>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::SectionAttr>(mx::ir::hl::SectionAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AssumeAlignedAttr>::Type>
+from_python<mx::AssumeAlignedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ForStmt>(mx::ForStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TagTypeKind>::Type>
+from_python<mx::TagTypeKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPAllocateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPAllocateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AVRInterruptAttrSpelling>::Type>
+from_python<mx::AVRInterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ForStmt>>(gap::generator<mx::ForStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AssertSharedLockAttr>::Type>
+from_python<mx::AssertSharedLockAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::SectionAttr>>(std::optional<mx::ir::hl::SectionAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TailPaddingUseRules>::Type>
+from_python<mx::TailPaddingUseRules>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AliasAttr>(mx::ir::hl::AliasAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateArgumentDependence>::Type>
+from_python<mx::TemplateArgumentDependence>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUWavesPerEUAttr>>(std::optional<mx::AMDGPUWavesPerEUAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AssertExclusiveLockAttr>::Type>
+from_python<mx::AssertExclusiveLockAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AliasAttr>>(std::optional<mx::ir::hl::AliasAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateNameDependence>::Type>
+from_python<mx::TemplateNameDependence>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LShrOp>(mx::ir::llvm::LShrOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AssertCapabilityAttr>::Type>
+from_python<mx::AssertCapabilityAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LShrOp>>(std::optional<mx::ir::llvm::LShrOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TemplateSpecializationKind>::Type>
+from_python<mx::TemplateSpecializationKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXX11NoReturnAttr>>(gap::generator<mx::CXX11NoReturnAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AsmLabelAttr>::Type>
+from_python<mx::AsmLabelAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ErrorAttr>(mx::ir::hl::ErrorAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TextDiagnosticFormat>::Type>
+from_python<mx::TextDiagnosticFormat>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ForStmt>>(std::optional<mx::ForStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ThreadModelKind>::Type>
+from_python<mx::ThreadModelKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ErrorAttr>>(std::optional<mx::ir::hl::ErrorAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArtificialAttr>::Type>
+from_python<mx::ArtificialAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ForStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ForStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ThreadStorageClassSpecifier>::Type>
+from_python<mx::ThreadStorageClassSpecifier>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CountedByAttr>(mx::ir::hl::CountedByAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmNewAttr>::Type>
+from_python<mx::ArmNewAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CountedByAttr>>(std::optional<mx::ir::hl::CountedByAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TrailingAllocKind>::Type>
+from_python<mx::TrailingAllocKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LandingpadOp>(mx::ir::llvm::LandingpadOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmLocallyStreamingAttr>::Type>
+from_python<mx::ArmLocallyStreamingAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CleanupAttr>(mx::ir::hl::CleanupAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TranslationUnitKind>::Type>
+from_python<mx::TranslationUnitKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LandingpadOp>>(std::optional<mx::ir::llvm::LandingpadOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TrivialAutoVarInitKind>::Type>
+from_python<mx::TrivialAutoVarInitKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXX11NoReturnAttr>>(std::optional<mx::CXX11NoReturnAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArmBuiltinAliasAttr>::Type>
+from_python<mx::ArmBuiltinAliasAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUNumVGPRAttr>>(gap::generator<mx::AMDGPUNumVGPRAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeDependence>::Type>
+from_python<mx::TypeDependence>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CleanupAttr>>(std::optional<mx::ir::hl::CleanupAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArgumentWithTypeTagAttr>::Type>
+from_python<mx::ArgumentWithTypeTagAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AlignedAttr>(mx::ir::hl::AlignedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeLocClass>::Type>
+from_python<mx::TypeLocClass>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoadOp>(mx::ir::llvm::LoadOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ArcWeakrefUnavailableAttr>::Type>
+from_python<mx::ArcWeakrefUnavailableAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LinkerOptionsOp>(mx::ir::llvm::LinkerOptionsOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeOfKind>::Type>
+from_python<mx::TypeOfKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AlignedAttr>>(std::optional<mx::ir::hl::AlignedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeSpecifierSign>::Type>
+from_python<mx::TypeSpecifierSign>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TranslationUnitDecl>>(gap::generator<mx::TranslationUnitDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86NoCfCheckAttr>::Type>
+from_python<mx::AnyX86NoCfCheckAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AlwaysInlineAttr>(mx::ir::hl::AlwaysInlineAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeSpecifierType>::Type>
+from_python<mx::TypeSpecifierType>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LinkerOptionsOp>>(std::optional<mx::ir::llvm::LinkerOptionsOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86NoCallerSavedRegistersAttr>::Type>
+from_python<mx::AnyX86NoCallerSavedRegistersAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUNumVGPRAttr>>(std::optional<mx::AMDGPUNumVGPRAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeSpecifierWidth>::Type>
+from_python<mx::TypeSpecifierWidth>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AlwaysInlineAttr>>(std::optional<mx::ir::hl::AlwaysInlineAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnyX86InterruptAttr>::Type>
+from_python<mx::AnyX86InterruptAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDASharedAttr>>(gap::generator<mx::CUDASharedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeSpecifiersPipe>::Type>
+from_python<mx::TypeSpecifiersPipe>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MulOp>(mx::ir::llvm::MulOp) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::ARMInterruptAttrSpelling>::Type>
+from_python<mx::ARMInterruptAttrSpelling>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::NoInlineAttr>(mx::ir::hl::NoInlineAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::TypeTrait>::Type>
+from_python<mx::TypeTrait>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoadOp>>(std::optional<mx::ir::llvm::LoadOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AnalyzerNoReturnAttr>::Type>
+from_python<mx::AnalyzerNoReturnAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::NoInlineAttr>>(std::optional<mx::ir::hl::NoInlineAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryExprOrTypeTrait>::Type>
+from_python<mx::UnaryExprOrTypeTrait>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TranslationUnitDecl>>(std::optional<mx::TranslationUnitDecl>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlwaysDestroyAttr>::Type>
+from_python<mx::AlwaysDestroyAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ConstAttr>(mx::ir::hl::ConstAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::UnaryOperatorKind>::Type>
+from_python<mx::UnaryOperatorKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TranslationUnitDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TranslationUnitDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AllocSizeAttr>::Type>
+from_python<mx::AllocSizeAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ConstAttr>>(std::optional<mx::ir::hl::ConstAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::APValueKind>::Type>
+from_python<mx::APValueKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDASharedAttr>>(std::optional<mx::CUDASharedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VectorKind>::Type>
+from_python<mx::VectorKind>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DoStmt>(mx::DoStmt) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AllocAlignAttr>::Type>
+from_python<mx::AllocAlignAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LoaderUninitializedAttr>(mx::ir::hl::LoaderUninitializedAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::Visibility>::Type>
+from_python<mx::Visibility>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUNumSGPRAttr>(mx::AMDGPUNumSGPRAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignedAttr>::Type>
+from_python<mx::AlignedAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DoStmt>>(gap::generator<mx::DoStmt>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityForcedKinds>::Type>
+from_python<mx::VisibilityForcedKinds>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MulOp>>(std::optional<mx::ir::llvm::MulOp>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignNaturalAttr>::Type>
+from_python<mx::AlignNaturalAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUNumSGPRAttr>>(gap::generator<mx::AMDGPUNumSGPRAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::VisibilityFromDLLStorageClassKinds>::Type>
+from_python<mx::VisibilityFromDLLStorageClassKinds>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LoaderUninitializedAttr>>(std::optional<mx::ir::hl::LoaderUninitializedAttr>) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AttributeSyntax>::Type>
+from_python<mx::AttributeSyntax>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::NoInstrumentFunctionAttr>(mx::ir::hl::NoInstrumentFunctionAttr) noexcept;
+template MX_EXPORT std::optional<FromPythonReturnType<mx::AlignMac68kAttr>::Type>
+from_python<mx::AlignMac68kAttr>(BorrowedPyObject *obj) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::NoInstrumentFunctionAttr>>(std::optional<mx::ir::hl::NoInstrumentFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExcludeFromExplicitInstantiationAttrSpelling>(mx::ExcludeFromExplicitInstantiationAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::OrOp>(mx::ir::llvm::OrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnavailableAttrImplicitReason>(mx::UnavailableAttrImplicitReason) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PackedAttr>(mx::ir::hl::PackedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AcquiredBeforeAttr>(mx::AcquiredBeforeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::NoneTokenOp>(mx::ir::llvm::NoneTokenOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DecltypeType>(mx::DecltypeType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DoStmt>>(std::optional<mx::DoStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPForSimdDirective>>(gap::generator<mx::OMPForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::NoneTokenOp>>(std::optional<mx::ir::llvm::NoneTokenOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprConstantExprKind>(mx::ExprConstantExprKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUNumSGPRAttr>>(std::optional<mx::AMDGPUNumSGPRAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnavailableAttrSpelling>(mx::UnavailableAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDALaunchBoundsAttr>(mx::CUDALaunchBoundsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPGenericLoopDirective>>(gap::generator<mx::OMPGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PackedAttr>>(std::optional<mx::ir::hl::PackedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AcquiredAfterAttr>(mx::AcquiredAfterAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDALaunchBoundsAttr>>(gap::generator<mx::CUDALaunchBoundsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BuiltinType>(mx::BuiltinType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DoStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::DoStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPGenericLoopDirective>>(std::optional<mx::OMPGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PureAttr>(mx::ir::hl::PureAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypedefDecl>>(gap::generator<mx::TypedefDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PureAttr>>(std::optional<mx::ir::hl::PureAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprLValueClassification>(mx::ExprLValueClassification) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::WarnUnusedResultAttr>(mx::ir::hl::WarnUnusedResultAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UninitializedAttrSpelling>(mx::UninitializedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::OrOp>>(std::optional<mx::ir::llvm::OrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AcquireHandleAttr>(mx::AcquireHandleAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::WarnUnusedResultAttr>>(std::optional<mx::ir::hl::WarnUnusedResultAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BlockPointerType>(mx::BlockPointerType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDALaunchBoundsAttr>>(std::optional<mx::CUDALaunchBoundsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypedefDecl>>(std::optional<mx::TypedefDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RestrictAttr>(mx::ir::hl::RestrictAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprNullPointerConstantKind>(mx::ExprNullPointerConstantKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUKernelCallAttr>(mx::AMDGPUKernelCallAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnlikelyAttrSpelling>(mx::UnlikelyAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaCommentDecl>(mx::PragmaCommentDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprNullPointerConstantValueDependence>(mx::ExprNullPointerConstantValueDependence) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TopLevelStmtDecl>>(gap::generator<mx::TopLevelStmtDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnsafeBufferUsageAttrSpelling>(mx::UnsafeBufferUsageAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUKernelCallAttr>>(gap::generator<mx::AMDGPUKernelCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AcquireCapabilityAttr>(mx::AcquireCapabilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RestrictAttr>>(std::optional<mx::ir::hl::RestrictAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BitIntType>(mx::BitIntType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::PoisonOp>(mx::ir::llvm::PoisonOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPForSimdDirective>>(std::optional<mx::OMPForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::NoThrowAttr>(mx::ir::hl::NoThrowAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeAliasDecl>>(gap::generator<mx::TypeAliasDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::PoisonOp>>(std::optional<mx::ir::llvm::PoisonOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprSideEffectsKind>(mx::ExprSideEffectsKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::NoThrowAttr>>(std::optional<mx::ir::hl::NoThrowAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnusedAttrSpelling>(mx::UnusedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::NonNullAttr>(mx::ir::hl::NonNullAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AVRSignalAttr>(mx::AVRSignalAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TopLevelStmtDecl>>(std::optional<mx::TopLevelStmtDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BTFTagAttributedType>(mx::BTFTagAttributedType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUKernelCallAttr>>(std::optional<mx::AMDGPUKernelCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprisModifiableLvalueResult>(mx::ExprisModifiableLvalueResult) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::PtrToIntOp>(mx::ir::llvm::PtrToIntOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UseHandleAttrSpelling>(mx::UseHandleAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDAInvalidTargetAttr>(mx::CUDAInvalidTargetAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPForDirective>>(gap::generator<mx::OMPForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::NonNullAttr>>(std::optional<mx::ir::hl::NonNullAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeAliasDecl>>(std::optional<mx::TypeAliasDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::PtrToIntOp>>(std::optional<mx::ir::llvm::PtrToIntOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AVRInterruptAttr>(mx::AVRInterruptAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAInvalidTargetAttr>>(gap::generator<mx::CUDAInvalidTargetAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AttributedType>(mx::AttributedType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TopLevelStmtDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TopLevelStmtDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExternalSourceSymbolAttrSpelling>(mx::ExternalSourceSymbolAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LeafAttr>(mx::ir::hl::LeafAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsedAttrSpelling>(mx::UsedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroutineBodyStmt>(mx::CoroutineBodyStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPForDirective>>(std::optional<mx::OMPForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ContinueStmt>(mx::ContinueStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeAliasTemplateDecl>>(std::optional<mx::TypeAliasTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroutineBodyStmt>>(gap::generator<mx::CoroutineBodyStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FallThroughAttrSpelling>(mx::FallThroughAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LeafAttr>>(std::optional<mx::ir::hl::LeafAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UserDefinedLiteralLiteralOperatorKind>(mx::UserDefinedLiteralLiteralOperatorKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ColdAttr>(mx::ir::hl::ColdAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ARMInterruptAttr>(mx::ARMInterruptAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ResumeOp>(mx::ir::llvm::ResumeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AtomicType>(mx::AtomicType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ResumeOp>>(std::optional<mx::ir::llvm::ResumeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FastCallAttrSpelling>(mx::FastCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ColdAttr>>(std::optional<mx::ir::hl::ColdAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsingIfExistsAttrSpelling>(mx::UsingIfExistsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAInvalidTargetAttr>>(std::optional<mx::CUDAInvalidTargetAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUWavesPerEUAttr>(mx::AMDGPUWavesPerEUAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUFlatWorkGroupSizeAttr>(mx::AMDGPUFlatWorkGroupSizeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IncompleteArrayType>(mx::IncompleteArrayType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::XRayLogArgsAttr>(mx::XRayLogArgsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeAliasTemplateDecl>>(gap::generator<mx::TypeAliasTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TransparentUnionAttr>(mx::ir::hl::TransparentUnionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FinalAttrSpelling>(mx::FinalAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUFlatWorkGroupSizeAttr>>(gap::generator<mx::AMDGPUFlatWorkGroupSizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UuidAttrSpelling>(mx::UuidAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SDivOp>(mx::ir::llvm::SDivOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUNumVGPRAttr>(mx::AMDGPUNumVGPRAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ReturnOp>(mx::ir::llvm::ReturnOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentSizedArrayType>(mx::DependentSizedArrayType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroutineBodyStmt>>(std::optional<mx::CoroutineBodyStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FlagEnumAttrSpelling>(mx::FlagEnumAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TransparentUnionAttr>>(std::optional<mx::ir::hl::TransparentUnionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VarDeclDefinitionKind>(mx::VarDeclDefinitionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ReturnOp>>(std::optional<mx::ir::llvm::ReturnOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FlattenAttrSpelling>(mx::FlattenAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ReturnsTwiceAttr>(mx::ir::hl::ReturnsTwiceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VarDeclInitializationStyle>(mx::VarDeclInitializationStyle) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CoroutineBodyStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::CoroutineBodyStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUNumSGPRAttr>(mx::AMDGPUNumSGPRAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SExtOp>(mx::ir::llvm::SExtOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstantArrayType>(mx::ConstantArrayType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ReturnsTwiceAttr>>(std::optional<mx::ir::hl::ReturnsTwiceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDistributeSimdDirective>>(gap::generator<mx::OMPDistributeSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::MayAliasAttr>(mx::ir::hl::MayAliasAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDistributeSimdDirective>>(std::optional<mx::OMPDistributeSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUFlatWorkGroupSizeAttr>>(std::optional<mx::AMDGPUFlatWorkGroupSizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FormatArgAttrSpelling>(mx::FormatArgAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SDivOp>>(std::optional<mx::ir::llvm::SDivOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VarDeclTLSKind>(mx::VarDeclTLSKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDAHostAttr>(mx::CUDAHostAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUKernelCallAttr>(mx::AMDGPUKernelCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceBuiltinTextureTypeAttr>(mx::CUDADeviceBuiltinTextureTypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AdjustedType>(mx::AdjustedType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAHostAttr>>(gap::generator<mx::CUDAHostAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinTemplateDecl>>(gap::generator<mx::BuiltinTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::MayAliasAttr>>(std::optional<mx::ir::hl::MayAliasAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FormatAttrSpelling>(mx::FormatAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::UnusedAttr>(mx::ir::hl::UnusedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VecReturnAttrSpelling>(mx::VecReturnAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StaticAssertDecl>(mx::StaticAssertDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDistributeParallelForSimdDirective>>(gap::generator<mx::OMPDistributeParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaDetectMismatchDecl>(mx::PragmaDetectMismatchDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinTemplateDecl>>(std::optional<mx::BuiltinTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StaticAssertDecl>>(gap::generator<mx::StaticAssertDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUFlatWorkGroupSizeAttr>(mx::AMDGPUFlatWorkGroupSizeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::UnusedAttr>>(std::optional<mx::ir::hl::UnusedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DecayedType>(mx::DecayedType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::UsedAttr>(mx::ir::hl::UsedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionDeclTemplatedKind>(mx::FunctionDeclTemplatedKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SExtOp>>(std::optional<mx::ir::llvm::SExtOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VectorCallAttrSpelling>(mx::VectorCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::UsedAttr>>(std::optional<mx::ir::hl::UsedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDistributeParallelForSimdDirective>>(std::optional<mx::OMPDistributeParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAHostAttr>>(std::optional<mx::CUDAHostAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionReturnThunksAttrKind>(mx::FunctionReturnThunksAttrKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::GNUInlineAttr>(mx::ir::hl::GNUInlineAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VisibilityAttrSpelling>(mx::VisibilityAttrSpelling) noexcept;
 
 template MX_EXPORT SharedPyObject *to_python<mx::AArch64VectorPcsAttr>(mx::AArch64VectorPcsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ZeroCallUsedRegsAttr>(mx::ZeroCallUsedRegsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeWithKeyword>(mx::TypeWithKeyword) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AArch64VectorPcsAttr>>(gap::generator<mx::AArch64VectorPcsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionReturnThunksAttrSpelling>(mx::FunctionReturnThunksAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StaticAssertDecl>>(std::optional<mx::StaticAssertDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VisibilityAttrVisibilityType>(mx::VisibilityAttrVisibilityType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::GNUInlineAttr>>(std::optional<mx::ir::hl::GNUInlineAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NamespaceAliasDecl>>(gap::generator<mx::NamespaceAliasDecl>) noexcept;
+
+template MX_EXPORT SharedPyObject *to_python<mx::AArch64SVEPcsAttr>(mx::AArch64SVEPcsAttr) noexcept;
+
+template MX_EXPORT SharedPyObject *to_python<mx::ElaboratedType>(mx::ElaboratedType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SRemOp>(mx::ir::llvm::SRemOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateTemplateParmDecl>>(gap::generator<mx::TemplateTemplateParmDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SIToFPOp>(mx::ir::llvm::SIToFPOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionTypeAArch64SMETypeAttributes>(mx::FunctionTypeAArch64SMETypeAttributes) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::NoCfCheckAttr>(mx::ir::hl::NoCfCheckAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WarnUnusedAttrSpelling>(mx::WarnUnusedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::StaticAssertDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::StaticAssertDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateTemplateParmDecl>>(std::optional<mx::TemplateTemplateParmDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SIToFPOp>>(std::optional<mx::ir::llvm::SIToFPOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ZeroCallUsedRegsAttr>(mx::ZeroCallUsedRegsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::NoCfCheckAttr>>(std::optional<mx::ir::hl::NoCfCheckAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentTemplateSpecializationType>(mx::DependentTemplateSpecializationType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr>(mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDistributeParallelForDirective>>(gap::generator<mx::OMPDistributeParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDAGlobalAttr>(mx::CUDAGlobalAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionTypeArmStateValue>(mx::FunctionTypeArmStateValue) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceBuiltinSurfaceTypeAttr>(mx::CUDADeviceBuiltinSurfaceTypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WarnUnusedResultAttrSpelling>(mx::WarnUnusedResultAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAGlobalAttr>>(gap::generator<mx::CUDAGlobalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDistributeParallelForDirective>>(std::optional<mx::OMPDistributeParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AArch64VectorPcsAttr>>(std::optional<mx::AArch64VectorPcsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GNUInlineAttrSpelling>(mx::GNUInlineAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr>>(std::optional<mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WeakAttrSpelling>(mx::WeakAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SRemOp>>(std::optional<mx::ir::llvm::SRemOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::XRayLogArgsAttr>(mx::XRayLogArgsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AvailabilityAttrAttr>(mx::ir::hl::AvailabilityAttrAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentNameType>(mx::DependentNameType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoreturnStmt>(mx::CoreturnStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GuardedVarAttrSpelling>(mx::GuardedVarAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXTryStmt>(mx::CXXTryStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WeakImportAttrSpelling>(mx::WeakImportAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoreturnStmt>>(gap::generator<mx::CoreturnStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::XRayInstrumentAttr>(mx::XRayInstrumentAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AvailabilityAttrAttr>>(std::optional<mx::ir::hl::AvailabilityAttrAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VectorType>(mx::VectorType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::FallthroughAttr>(mx::ir::hl::FallthroughAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HIPManagedAttrSpelling>(mx::HIPManagedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::NoProfileInstrumentFunctionAttr>(mx::ir::hl::NoProfileInstrumentFunctionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WeakRefAttrSpelling>(mx::WeakRefAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAGlobalAttr>>(std::optional<mx::CUDAGlobalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::X86ForceAlignArgPointerAttr>(mx::X86ForceAlignArgPointerAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ShlOp>(mx::ir::llvm::ShlOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExtVectorType>(mx::ExtVectorType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::FallthroughAttr>>(std::optional<mx::ir::hl::FallthroughAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDistributeDirective>>(gap::generator<mx::OMPDistributeDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SelectOp>(mx::ir::llvm::SelectOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLParamModifierAttrSpelling>(mx::HLSLParamModifierAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AArch64SVEPcsAttr>(mx::AArch64SVEPcsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyExportNameAttrSpelling>(mx::WebAssemblyExportNameAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SelectOp>>(std::optional<mx::ir::llvm::SelectOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCCompatibleAliasDecl>>(gap::generator<mx::ObjCCompatibleAliasDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPMapClauseKind>(mx::OpenMPMapClauseKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDistributeDirective>>(std::optional<mx::OMPDistributeDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRequiresSuperAttr>>(std::optional<mx::ObjCRequiresSuperAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCCompatibleAliasDecl>>(std::optional<mx::ObjCCompatibleAliasDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPMapModifierKind>(mx::OpenMPMapModifierKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLShaderAttrShaderType>(mx::HLSLShaderAttrShaderType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StmtExpr>>(std::optional<mx::StmtExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyImportModuleAttrSpelling>(mx::WebAssemblyImportModuleAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncludeMacrosMacroDirective>>(std::optional<mx::IncludeMacrosMacroDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WorkGroupSizeHintAttr>(mx::WorkGroupSizeHintAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPMotionModifierKind>(mx::OpenMPMotionModifierKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsingType>(mx::UsingType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::StmtExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::StmtExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HotAttrSpelling>(mx::HotAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFPToSIOp>>(std::optional<mx::ir::llvm::VPFPToSIOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyImportNameAttrSpelling>(mx::WebAssemblyImportNameAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncErrorAttr>>(std::optional<mx::SwiftAsyncErrorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyImportNameAttr>(mx::WebAssemblyImportNameAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPNumTasksClauseModifier>(mx::OpenMPNumTasksClauseModifier) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsingShadowDecl>(mx::UsingShadowDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPOrderClauseKind>(mx::OpenMPOrderClauseKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IBActionAttrSpelling>(mx::IBActionAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPOrderClauseModifier>(mx::OpenMPOrderClauseModifier) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::X86ForceAlignArgPointerAttrSpelling>(mx::X86ForceAlignArgPointerAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPReductionClauseModifier>(mx::OpenMPReductionClauseModifier) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NamespaceAliasDecl>>(std::optional<mx::NamespaceAliasDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRequiresPropertyDefsAttr>>(gap::generator<mx::ObjCRequiresPropertyDefsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AllocSizeAttrSpelling>(mx::AllocSizeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPScheduleClauseKind>(mx::OpenMPScheduleClauseKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyImportModuleAttr>(mx::WebAssemblyImportModuleAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFPToUIOp>(mx::ir::llvm::VPFPToUIOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsGenericLoopDirective>>(gap::generator<mx::OMPTeamsGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPScheduleClauseModifier>(mx::OpenMPScheduleClauseModifier) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IBOutletAttrSpelling>(mx::IBOutletAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncludeNextMacroDirective>>(gap::generator<mx::IncludeNextMacroDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::XRayInstrumentAttrSpelling>(mx::XRayInstrumentAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFPToUIOp>>(std::optional<mx::ir::llvm::VPFPToUIOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsGenericLoopDirective>>(std::optional<mx::OMPTeamsGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenMPSeverityClauseKind>(mx::OpenMPSeverityClauseKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BaseUsingDecl>(mx::BaseUsingDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OverloadedOperatorKind>(mx::OverloadedOperatorKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LinkageSpecDecl>>(gap::generator<mx::LinkageSpecDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncCallAttr>>(gap::generator<mx::SwiftAsyncCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IBOutletCollectionAttrSpelling>(mx::IBOutletCollectionAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OverloadsShown>(mx::OverloadsShown) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::XRayLogArgsAttrSpelling>(mx::XRayLogArgsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRequiresPropertyDefsAttr>>(std::optional<mx::ObjCRequiresPropertyDefsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyExportNameAttr>(mx::WebAssemblyExportNameAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParameterABI>(mx::ParameterABI) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedUsingType>(mx::UnresolvedUsingType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFPTruncOp>(mx::ir::llvm::VPFPTruncOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDistributeParallelForSimdDirective>>(gap::generator<mx::OMPTeamsDistributeParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFPTruncOp>>(std::optional<mx::ir::llvm::VPFPTruncOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IFuncAttrSpelling>(mx::IFuncAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncludeNextMacroDirective>>(std::optional<mx::IncludeNextMacroDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ZeroCallUsedRegsAttrSpelling>(mx::ZeroCallUsedRegsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SourceLocExpr>>(gap::generator<mx::SourceLocExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WeakRefAttr>(mx::WeakRefAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncCallAttr>>(std::optional<mx::SwiftAsyncCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnaryTransformType>(mx::UnaryTransformType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParenLocsOffsets>(mx::ParenLocsOffsets) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LinkageSpecDecl>>(std::optional<mx::LinkageSpecDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFRemOp>(mx::ir::llvm::VPFRemOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ImplicitCastExprOnStack>(mx::ImplicitCastExprOnStack) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaFPKind>(mx::PragmaFPKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind>(mx::ZeroCallUsedRegsAttrZeroCallUsedRegsKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFRemOp>>(std::optional<mx::ir::llvm::VPFRemOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDistributeSimdDirective>>(gap::generator<mx::OMPTeamsDistributeSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaFloatControlKind>(mx::PragmaFloatControlKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDistributeSimdDirective>>(std::optional<mx::OMPTeamsDistributeSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCPreciseLifetimeAttr>>(gap::generator<mx::ObjCPreciseLifetimeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WeakImportAttr>(mx::WeakImportAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaMSCommentKind>(mx::PragmaMSCommentKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedUsingTypenameDecl>(mx::UnresolvedUsingTypenameDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaMSPointersToMembersKind>(mx::PragmaMSPointersToMembersKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InitPriorityAttrSpelling>(mx::InitPriorityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IncludeMacroDirective>(mx::IncludeMacroDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ASTDumpOutputFormat>(mx::ASTDumpOutputFormat) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SourceLocExpr>>(std::optional<mx::SourceLocExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImportDecl>>(gap::generator<mx::ImportDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncludeMacroDirective>>(gap::generator<mx::IncludeMacroDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IntelOclBiccAttrSpelling>(mx::IntelOclBiccAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaMSStructKind>(mx::PragmaMSStructKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AccessSpecifier>(mx::AccessSpecifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SourceLocExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::SourceLocExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WeakAttr>(mx::WeakAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaSectionFlag>(mx::PragmaSectionFlag) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypedefType>(mx::TypedefType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFmaOp>(mx::ir::llvm::VPFmaOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDistributeParallelForSimdDirective>>(std::optional<mx::OMPTeamsDistributeParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PredefinedIdentKind>(mx::PredefinedIdentKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImportDecl>>(std::optional<mx::ImportDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncAttr>>(gap::generator<mx::SwiftAsyncAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InternalLinkageAttrSpelling>(mx::InternalLinkageAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPFSubOp>(mx::ir::llvm::VPFSubOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AddrSpaceMapMangling>(mx::AddrSpaceMapMangling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCPreciseLifetimeAttr>>(std::optional<mx::ObjCPreciseLifetimeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WarnUnusedResultAttr>(mx::WarnUnusedResultAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Qualified>(mx::Qualified) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeOfType>(mx::TypeOfType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFSubOp>>(std::optional<mx::ir::llvm::VPFSubOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Visibility>>(std::optional<mx::Visibility>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RangeExprOffset>(mx::RangeExprOffset) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LTOVisibilityPublicAttrSpelling>(mx::LTOVisibilityPublicAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RangeLocOffset>(mx::RangeLocOffset) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlignRequirementKind>(mx::AlignRequirementKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RecordArgPassingKind>(mx::RecordArgPassingKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ValueDecl>>(std::optional<mx::ValueDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncAttr>>(std::optional<mx::SwiftAsyncAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FriendTemplateDecl>>(gap::generator<mx::FriendTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncludeMacroDirective>>(std::optional<mx::IncludeMacroDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WarnUnusedAttr>(mx::WarnUnusedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RefQualifierKind>(mx::RefQualifierKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeOfExprType>(mx::TypeOfExprType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReservedIdentifierStatus>(mx::ReservedIdentifierStatus) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LeafAttrSpelling>(mx::LeafAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReservedLiteralSuffixIdStatus>(mx::ReservedLiteralSuffixIdStatus) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AltivecSrcCompatKind>(mx::AltivecSrcCompatKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCOwnershipAttr>(mx::ObjCOwnershipAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDistributeParallelForDirective>>(gap::generator<mx::OMPTeamsDistributeParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPFmaOp>>(std::optional<mx::ir::llvm::VPFmaOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCContainerDecl>>(gap::generator<mx::ObjCContainerDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCOwnershipAttr>>(gap::generator<mx::ObjCOwnershipAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LifetimeBoundAttrSpelling>(mx::LifetimeBoundAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SFINAEResponse>(mx::SFINAEResponse) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArgumentKind>(mx::ArgumentKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SYCLMajorVersion>(mx::SYCLMajorVersion) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VisibilityAttr>(mx::VisibilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SanitizerOrdinal>(mx::SanitizerOrdinal) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SEHTryStmt>(mx::SEHTryStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SelectorLocationsKind>(mx::SelectorLocationsKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDistributeParallelForDirective>>(std::optional<mx::OMPTeamsDistributeParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ShaderStage>(mx::ShaderStage) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FriendTemplateDecl>>(std::optional<mx::FriendTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::AttributeKind>(mx::ir::AttributeKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCMethodDecl>>(gap::generator<mx::ObjCMethodDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StrictGuardStackCheckAttr>(mx::StrictGuardStackCheckAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LikelyAttrSpelling>(mx::LikelyAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StrictGuardStackCheckAttr>>(gap::generator<mx::StrictGuardStackCheckAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArraySizeModifier>(mx::ArraySizeModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCOwnershipAttr>>(std::optional<mx::ObjCOwnershipAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VectorCallAttr>(mx::VectorCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPIntToPtrOp>(mx::ir::llvm::VPIntToPtrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SEHExceptStmt>(mx::SEHExceptStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SignReturnAddressKeyKind>(mx::SignReturnAddressKeyKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LoaderUninitializedAttrSpelling>(mx::LoaderUninitializedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::BasicBlockOrder>(mx::ir::BasicBlockOrder) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArrayTypeTrait>(mx::ArrayTypeTrait) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SYCLUniqueStableNameExpr>(mx::SYCLUniqueStableNameExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Index>(mx::Index) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SignReturnAddressScopeKind>(mx::SignReturnAddressScopeKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VecTypeHintAttr>(mx::VecTypeHintAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SizeOfPackExpr>>(gap::generator<mx::SizeOfPackExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CompoundStmt>(mx::CompoundStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPIntToPtrOp>>(std::optional<mx::ir::llvm::VPIntToPtrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LoopHintAttrLoopHintState>(mx::LoopHintAttrLoopHintState) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Attribute>(mx::ir::Attribute) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AtomicScopeModelKind>(mx::AtomicScopeModelKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SignedOverflowBehaviorTy>(mx::SignedOverflowBehaviorTy) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUKernelCallAttrSpelling>(mx::AMDGPUKernelCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Attribute>(mx::ir::builtin::Attribute) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LoopHintAttrOptionType>(mx::LoopHintAttrOptionType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SourceLocIdentKind>(mx::SourceLocIdentKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AutoTypeKeyword>(mx::AutoTypeKeyword) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StrictGuardStackCheckAttr>>(std::optional<mx::StrictGuardStackCheckAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VecReturnAttr>(mx::VecReturnAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Attribute>>(std::optional<mx::ir::builtin::Attribute>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SEHFinallyStmt>(mx::SEHFinallyStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPLShrOp>(mx::ir::llvm::VPLShrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDistributeDirective>>(gap::generator<mx::OMPTeamsDistributeDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SpecialMemberFlags>(mx::SpecialMemberFlags) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LoopHintAttrSpelling>(mx::LoopHintAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SizeOfPackExpr>>(std::optional<mx::SizeOfPackExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AvailabilityResult>(mx::AvailabilityResult) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPLShrOp>>(std::optional<mx::ir::llvm::VPLShrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDistributeDirective>>(std::optional<mx::OMPTeamsDistributeDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SpecifierKind>(mx::SpecifierKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UuidAttr>(mx::UuidAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCNSObjectAttr>(mx::ObjCNSObjectAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SEHLeaveStmt>(mx::SEHLeaveStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::TypedAttr>(mx::ir::builtin::TypedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FileScopeAsmDecl>>(gap::generator<mx::FileScopeAsmDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCNSObjectAttr>>(gap::generator<mx::ObjCNSObjectAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::M68kRTDAttrSpelling>(mx::M68kRTDAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::TypedAttr>>(std::optional<mx::ir::builtin::TypedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BinaryOperatorKind>(mx::BinaryOperatorKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StackProtectorMode>(mx::StackProtectorMode) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Token>>(std::optional<mx::Token>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SizeOfPackExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::SizeOfPackExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSGuidDecl>(mx::MSGuidDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StorageClass>(mx::StorageClass) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReturnStmt>(mx::ReturnStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StorageDuration>(mx::StorageDuration) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FileScopeAsmDecl>>(std::optional<mx::FileScopeAsmDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::ElementsAttr>(mx::ir::builtin::ElementsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MIGServerRoutineAttrSpelling>(mx::MIGServerRoutineAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::ElementsAttr>>(std::optional<mx::ir::builtin::ElementsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Bits>(mx::Bits) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StoredNameKind>(mx::StoredNameKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskLoopSimdDirective>>(gap::generator<mx::OMPTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StrictFPAttr>(mx::StrictFPAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSABIAttrSpelling>(mx::MSABIAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPLoadOp>(mx::ir::llvm::VPLoadOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXConstructionKind>(mx::CXXConstructionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StrictFPAttr>>(gap::generator<mx::StrictFPAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsingIfExistsAttr>(mx::UsingIfExistsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StoredSpecifierKind>(mx::StoredSpecifierKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCForCollectionStmt>(mx::ObjCForCollectionStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCNSObjectAttr>>(std::optional<mx::ObjCNSObjectAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskLoopSimdDirective>>(std::optional<mx::OMPTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPLoadOp>>(std::optional<mx::ir::llvm::VPLoadOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExternCContextDecl>>(gap::generator<mx::ExternCContextDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StrictFlexArraysLevelKind>(mx::StrictFlexArraysLevelKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSInheritanceAttrSpelling>(mx::MSInheritanceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StringLiteralKind>(mx::StringLiteralKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXNewInitializationStyle>(mx::CXXNewInitializationStyle) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::AffineMapAttr>(mx::ir::builtin::AffineMapAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsedAttr>(mx::UsedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SubExpr>(mx::SubExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCAutoreleasePoolStmt>(mx::ObjCAutoreleasePoolStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPMulOp>(mx::ir::llvm::VPMulOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSP430InterruptAttrSpelling>(mx::MSP430InterruptAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::AffineMapAttr>>(std::optional<mx::ir::builtin::AffineMapAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CallingConv>(mx::CallingConv) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPMergeMinOp>(mx::ir::llvm::VPMergeMinOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskLoopDirective>>(gap::generator<mx::OMPTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SyncScope>(mx::SyncScope) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExternCContextDecl>>(std::optional<mx::ExternCContextDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::ArrayAttr>(mx::ir::builtin::ArrayAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnusedAttr>(mx::UnusedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPMergeMinOp>>(std::optional<mx::ir::llvm::VPMergeMinOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtTryStmt>(mx::ObjCAtTryStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StrictFPAttr>>(std::optional<mx::StrictFPAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSStructAttrSpelling>(mx::MSStructAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SubStmt>(mx::SubStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CanThrowResult>(mx::CanThrowResult) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::ArrayAttr>>(std::optional<mx::ir::builtin::ArrayAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskLoopDirective>>(std::optional<mx::OMPTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Syntax>(mx::Syntax) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExportDecl>>(gap::generator<mx::ExportDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodFamilyAttr>(mx::ObjCMethodFamilyAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MayAliasAttrSpelling>(mx::MayAliasAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCExternallyRetainedAttr>(mx::ObjCExternallyRetainedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CapturedRegionKind>(mx::CapturedRegionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCMethodFamilyAttr>>(gap::generator<mx::ObjCMethodFamilyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateArgument>>(gap::generator<mx::TemplateArgument>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TagTypeKind>(mx::TagTypeKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnsafeBufferUsageAttr>(mx::UnsafeBufferUsageAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPOrOp>(mx::ir::llvm::VPOrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtFinallyStmt>(mx::ObjCAtFinallyStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TQ>(mx::TQ) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MaybeUndefAttrSpelling>(mx::MaybeUndefAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::DenseArrayAttr>(mx::ir::builtin::DenseArrayAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CastKind>(mx::CastKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TailPaddingUseRules>(mx::TailPaddingUseRules) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UninitializedAttr>(mx::UninitializedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::DenseArrayAttr>>(std::optional<mx::ir::builtin::DenseArrayAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtCatchStmt>(mx::ObjCAtCatchStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateArgumentDependence>(mx::TemplateArgumentDependence) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExportDecl>>(std::optional<mx::ExportDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<std::vector<mx::TemplateArgument>>>(std::optional<std::vector<mx::TemplateArgument>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MicroMipsAttrSpelling>(mx::MicroMipsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPMulOp>>(std::optional<mx::ir::llvm::VPMulOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CharacterLiteralKind>(mx::CharacterLiteralKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ShuffleVectorExpr>(mx::ShuffleVectorExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsGenericLoopDirective>>(gap::generator<mx::OMPTargetTeamsGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RequiresExpr>(mx::RequiresExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnavailableAttr>(mx::UnavailableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StdCallAttr>(mx::StdCallAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtThrowStmt>(mx::ObjCAtThrowStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ShuffleVectorExpr>>(gap::generator<mx::ShuffleVectorExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MinSizeAttrSpelling>(mx::MinSizeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SpeculativeLoadHardeningAttr>(mx::SpeculativeLoadHardeningAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ClangABI>(mx::ClangABI) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateNameDependence>(mx::TemplateNameDependence) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsGenericLoopDirective>>(std::optional<mx::OMPTargetTeamsGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StdCallAttr>>(gap::generator<mx::StdCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MinVectorWidthAttrSpelling>(mx::MinVectorWidthAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateSpecializationKind>(mx::TemplateSpecializationKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CommentKind>(mx::CommentKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCMethodFamilyAttr>>(std::optional<mx::ObjCMethodFamilyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeVisibilityAttr>(mx::TypeVisibilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::DenseIntOrFPElementsAttr>(mx::ir::builtin::DenseIntOrFPElementsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtSynchronizedStmt>(mx::ObjCAtSynchronizedStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TextDiagnosticFormat>(mx::TextDiagnosticFormat) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EmptyDecl>>(gap::generator<mx::EmptyDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::DenseIntOrFPElementsAttr>>(std::optional<mx::ir::builtin::DenseIntOrFPElementsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDistributeSimdDirective>>(gap::generator<mx::OMPTargetTeamsDistributeSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ThreadModelKind>(mx::ThreadModelKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Mips16AttrSpelling>(mx::Mips16AttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ThreadStorageClassSpecifier>(mx::ThreadStorageClassSpecifier) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ComparisonCategoryResult>(mx::ComparisonCategoryResult) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::DenseStringElementsAttr>(mx::ir::builtin::DenseStringElementsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeTagForDatatypeAttr>(mx::TypeTagForDatatypeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPOrOp>>(std::optional<mx::ir::llvm::VPOrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPExecutableDirective>(mx::OMPExecutableDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TrailingAllocKind>(mx::TrailingAllocKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EmptyDecl>>(std::optional<mx::EmptyDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ShuffleVectorExpr>>(std::optional<mx::ShuffleVectorExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDistributeSimdDirective>>(std::optional<mx::OMPTargetTeamsDistributeSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::DenseStringElementsAttr>>(std::optional<mx::ir::builtin::DenseStringElementsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MipsInterruptAttrInterruptType>(mx::MipsInterruptAttrInterruptType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TranslationUnitKind>(mx::TranslationUnitKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ComparisonCategoryType>(mx::ComparisonCategoryType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StdCallAttr>>(std::optional<mx::StdCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<FilePathMap>(FilePathMap) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TrivialAutoVarInitKind>(mx::TrivialAutoVarInitKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TryAcquireCapabilityAttr>(mx::TryAcquireCapabilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::DenseResourceElementsAttr>(mx::ir::builtin::DenseResourceElementsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CapturedStmt>(mx::CapturedStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeDependence>(mx::TypeDependence) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MipsInterruptAttrSpelling>(mx::MipsInterruptAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ShuffleVectorExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ShuffleVectorExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CompilingModuleKind>(mx::CompilingModuleKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeLocClass>(mx::TypeLocClass) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDistributeParallelForSimdDirective>>(gap::generator<mx::OMPTargetTeamsDistributeParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::DenseResourceElementsAttr>>(std::optional<mx::ir::builtin::DenseResourceElementsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MipsLongCallAttrSpelling>(mx::MipsLongCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCIndependentClassAttr>(mx::ObjCIndependentClassAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ComplexRangeKind>(mx::ComplexRangeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCExplicitProtocolImplAttr>(mx::ObjCExplicitProtocolImplAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TrivialABIAttr>(mx::TrivialABIAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeOfKind>(mx::TypeOfKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CapturedDecl>(mx::CapturedDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIndependentClassAttr>>(gap::generator<mx::ObjCIndependentClassAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDistributeParallelForSimdDirective>>(std::optional<mx::OMPTargetTeamsDistributeParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::DictionaryAttr>(mx::ir::builtin::DictionaryAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MipsShortCallAttrSpelling>(mx::MipsShortCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeSpecifierSign>(mx::TypeSpecifierSign) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstantResultStorageKind>(mx::ConstantResultStorageKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::DictionaryAttr>>(std::optional<mx::ir::builtin::DictionaryAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TransparentUnionAttr>(mx::TransparentUnionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPPtrToIntOp>(mx::ir::llvm::VPPtrToIntOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPErrorDirective>(mx::OMPErrorDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPPtrToIntOp>>(std::optional<mx::ir::llvm::VPPtrToIntOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ModeAttrSpelling>(mx::ModeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StandaloneDebugAttr>(mx::StandaloneDebugAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstexprSpecKind>(mx::ConstexprSpecKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SharedTrylockFunctionAttr>(mx::SharedTrylockFunctionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDistributeParallelForDirective>>(gap::generator<mx::OMPTargetTeamsDistributeParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StandaloneDebugAttr>>(gap::generator<mx::StandaloneDebugAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ThisCallAttr>(mx::ThisCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::FloatAttr>(mx::ir::builtin::FloatAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDispatchDirective>(mx::OMPDispatchDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeSpecifierType>(mx::TypeSpecifierType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MustTailAttrSpelling>(mx::MustTailAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeSpecifierWidth>(mx::TypeSpecifierWidth) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoreFoundationABI>(mx::CoreFoundationABI) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIndependentClassAttr>>(std::optional<mx::ObjCIndependentClassAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDistributeParallelForDirective>>(std::optional<mx::OMPTargetTeamsDistributeParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::FloatAttr>>(std::optional<mx::ir::builtin::FloatAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSConsumedAttrSpelling>(mx::NSConsumedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeSpecifiersPipe>(mx::TypeSpecifiersPipe) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DataPositionTy>(mx::DataPositionTy) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceAndOp>(mx::ir::llvm::VPReduceAndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TestTypestateAttr>(mx::TestTypestateAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceAddOp>(mx::ir::llvm::VPReduceAddOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDepobjDirective>(mx::OMPDepobjDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceAddOp>>(std::optional<mx::ir::llvm::VPReduceAddOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCInterfaceDecl>>(gap::generator<mx::ObjCInterfaceDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::IntegerSetAttr>(mx::ir::builtin::IntegerSetAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSConsumesSelfAttrSpelling>(mx::NSConsumesSelfAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::IntegerAttr>(mx::ir::builtin::IntegerAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeductionCandidate>(mx::DeductionCandidate) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::IntegerAttr>>(std::optional<mx::ir::builtin::IntegerAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TargetVersionAttr>(mx::TargetVersionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StandaloneDebugAttr>>(std::optional<mx::StandaloneDebugAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPCriticalDirective>(mx::OMPCriticalDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FormatArgAttr>>(gap::generator<mx::FormatArgAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsAutoreleasedAttrSpelling>(mx::NSReturnsAutoreleasedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnnotateTypeAttr>>(std::optional<mx::AnnotateTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DefaultArgKind>(mx::DefaultArgKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MayAliasAttr>>(gap::generator<mx::MayAliasAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TargetClonesAttr>(mx::TargetClonesAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CastExpr>>(gap::generator<mx::CastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPCancellationPointDirective>(mx::OMPCancellationPointDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PlusOp>(mx::ir::hl::PlusOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroVAOpt>>(gap::generator<mx::MacroVAOpt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SEHExceptStmt>>(std::optional<mx::SEHExceptStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsNotRetainedAttrSpelling>(mx::NSReturnsNotRetainedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::OpaqueValueExprOp>>(std::optional<mx::ir::hl::OpaqueValueExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DefaultCallingConvention>(mx::DefaultCallingConvention) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SEHExceptStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::SEHExceptStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroSubstitution>>(gap::generator<mx::MacroSubstitution>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FormatArgAttr>>(std::optional<mx::FormatArgAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDistributeDirective>>(gap::generator<mx::OMPTargetTeamsDistributeDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MayAliasAttr>>(std::optional<mx::MayAliasAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsRetainedAttrSpelling>(mx::NSReturnsRetainedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CastExpr>>(std::optional<mx::CastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DefaultVisiblityExportMapping>(mx::DefaultVisiblityExportMapping) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PlusOp>>(std::optional<mx::ir::hl::PlusOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TargetAttr>(mx::TargetAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPCancelDirective>(mx::OMPCancelDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AddressSpaceAttr>>(gap::generator<mx::AddressSpaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDistributeDirective>>(std::optional<mx::OMPTargetTeamsDistributeDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCProtocolDecl>(mx::ObjCProtocolDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroSubstitution>>(std::optional<mx::MacroSubstitution>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PostDecOp>(mx::ir::hl::PostDecOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NVPTXKernelAttrSpelling>(mx::NVPTXKernelAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FlattenAttr>>(gap::generator<mx::FlattenAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DesignatorKind>(mx::DesignatorKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCProtocolDecl>>(std::optional<mx::ObjCProtocolDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TLSModelAttr>(mx::TLSModelAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MatrixSubscriptExpr>>(gap::generator<mx::MatrixSubscriptExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPBarrierDirective>(mx::OMPBarrierDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PostDecOp>>(std::optional<mx::ir::hl::PostDecOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NakedAttrSpelling>(mx::NakedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCProtocolDecl>>(gap::generator<mx::ObjCProtocolDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DiagnosticLevelMask>(mx::DiagnosticLevelMask) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MaxFieldAlignmentAttr>>(gap::generator<mx::MaxFieldAlignmentAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetSimdDirective>>(gap::generator<mx::OMPTargetSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AddressSpaceAttr>>(std::optional<mx::AddressSpaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SysVABIAttr>(mx::SysVABIAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PostIncOp>(mx::ir::hl::PostIncOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPAtomicDirective>(mx::OMPAtomicDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PostIncOp>>(std::optional<mx::ir::hl::PostIncOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NamedDeclExplicitVisibilityKind>(mx::NamedDeclExplicitVisibilityKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CompoundStmt>(mx::CompoundStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ElaboratedTypeKeyword>(mx::ElaboratedTypeKeyword) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FlattenAttr>>(std::optional<mx::FlattenAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetSimdDirective>>(std::optional<mx::OMPTargetSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MatrixSubscriptExpr>>(std::optional<mx::MatrixSubscriptExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoBuiltinAttrSpelling>(mx::NoBuiltinAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CompoundStmt>>(gap::generator<mx::CompoundStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EscapeChar>(mx::EscapeChar) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::MatrixSubscriptExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::MatrixSubscriptExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftPrivateAttr>(mx::SwiftPrivateAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCProtocolDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCProtocolDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDirective>(mx::OMPTeamsDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PreDecOp>(mx::ir::hl::PreDecOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroVAOpt>>(std::optional<mx::MacroVAOpt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MaxFieldAlignmentAttr>>(std::optional<mx::MaxFieldAlignmentAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoCommonAttrSpelling>(mx::NoCommonAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PreDecOp>>(std::optional<mx::ir::hl::PreDecOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExceptionHandlingKind>(mx::ExceptionHandlingKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WebAssemblyFuncrefAttr>>(gap::generator<mx::WebAssemblyFuncrefAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftNewTypeAttr>(mx::SwiftNewTypeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CompoundStmt>>(std::optional<mx::CompoundStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskyieldDirective>(mx::OMPTaskyieldDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PreIncOp>(mx::ir::hl::PreIncOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetParallelGenericLoopDirective>>(gap::generator<mx::OMPTargetParallelGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImplicitCastExpr>>(gap::generator<mx::ImplicitCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoDebugAttrSpelling>(mx::NoDebugAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FlagEnumAttr>>(gap::generator<mx::FlagEnumAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExceptionSpecificationType>(mx::ExceptionSpecificationType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PreIncOp>>(std::optional<mx::ir::hl::PreIncOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetParallelGenericLoopDirective>>(std::optional<mx::OMPTargetParallelGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CompoundStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::CompoundStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftNameAttr>(mx::SwiftNameAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSVtorDispAttr>(mx::MSVtorDispAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskwaitDirective>(mx::OMPTaskwaitDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WebAssemblyFuncrefAttr>>(std::optional<mx::WebAssemblyFuncrefAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoDerefAttrSpelling>(mx::NoDerefAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSVtorDispAttr>>(gap::generator<mx::MSVtorDispAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExcessPrecisionKind>(mx::ExcessPrecisionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PredefinedExprOp>(mx::ir::hl::PredefinedExprOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoDestroyAttrSpelling>(mx::NoDestroyAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PredefinedExprOp>>(std::optional<mx::ir::hl::PredefinedExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExplicitSpecKind>(mx::ExplicitSpecKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImplicitCastExpr>>(std::optional<mx::ImplicitCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftImportPropertyAsAccessorsAttr>(mx::SwiftImportPropertyAsAccessorsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FlagEnumAttr>>(std::optional<mx::FlagEnumAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskgroupDirective>(mx::OMPTaskgroupDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ImplicitCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ImplicitCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TokenContext>>(std::optional<mx::TokenContext>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSVtorDispAttr>>(std::optional<mx::MSVtorDispAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoDuplicateAttrSpelling>(mx::NoDuplicateAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PreferredAlignOfExprOp>(mx::ir::hl::PreferredAlignOfExprOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprDependence>(mx::ExprDependence) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PreferredAlignOfExprOp>>(std::optional<mx::ir::hl::PreferredAlignOfExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftImportAsNonGenericAttr>(mx::SwiftImportAsNonGenericAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UPtrAttr>(mx::UPtrAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskDirective>(mx::OMPTaskDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSPropertyRefExpr>(mx::MSPropertyRefExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetParallelForSimdDirective>>(gap::generator<mx::OMPTargetParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MaterializeTemporaryExpr>>(gap::generator<mx::MaterializeTemporaryExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoEscapeAttrSpelling>(mx::NoEscapeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UPtrAttr>>(gap::generator<mx::UPtrAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprObjectKind>(mx::ExprObjectKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FinalAttr>(mx::FinalAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetParallelForSimdDirective>>(std::optional<mx::OMPTargetParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FinalAttr>>(gap::generator<mx::FinalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftErrorAttr>(mx::SwiftErrorAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCImplementationDecl>(mx::ObjCImplementationDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetUpdateDirective>(mx::OMPTargetUpdateDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RealOp>(mx::ir::hl::RealOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoInlineAttrSpelling>(mx::NoInlineAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PreferredAlignOfTypeOp>(mx::ir::hl::PreferredAlignOfTypeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprOffsets>(mx::ExprOffsets) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PreferredAlignOfTypeOp>>(std::optional<mx::ir::hl::PreferredAlignOfTypeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoInstrumentFunctionAttrSpelling>(mx::NoInstrumentFunctionAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCImplDecl>(mx::ObjCImplDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprValueKind>(mx::ExprValueKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCImplementationDecl>>(gap::generator<mx::ObjCImplementationDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftCallAttr>(mx::SwiftCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCImplDecl>>(gap::generator<mx::ObjCImplDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDirective>(mx::OMPTargetTeamsDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MaterializeTemporaryExpr>>(std::optional<mx::MaterializeTemporaryExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPSimdDirective>>(gap::generator<mx::OMPSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UPtrAttr>>(std::optional<mx::UPtrAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<std::pair<uint32_t, uint32_t>>>(std::optional<std::pair<uint32_t, uint32_t>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSStructAttr>(mx::MSStructAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoMergeAttrSpelling>(mx::NoMergeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SEHFinallyStmt>(mx::SEHFinallyStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExpressionTrait>(mx::ExpressionTrait) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSStructAttr>>(gap::generator<mx::MSStructAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetParallelForDirective>>(gap::generator<mx::OMPTargetParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::MaterializeTemporaryExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::MaterializeTemporaryExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftBridgedTypedefAttr>(mx::SwiftBridgedTypedefAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SEHFinallyStmt>>(gap::generator<mx::SEHFinallyStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetParallelDirective>(mx::OMPTargetParallelDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FinalAttr>>(std::optional<mx::FinalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EmptyTokenTreeNode>>(std::optional<mx::EmptyTokenTreeNode>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RealOp>>(std::optional<mx::ir::hl::RealOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetParallelForDirective>>(std::optional<mx::OMPTargetParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCImplDecl>>(std::optional<mx::ObjCImplDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoMicroMipsAttrSpelling>(mx::NoMicroMipsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExplicitCastExpr>(mx::ExplicitCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExtKind>(mx::ExtKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXDynamicCastExpr>(mx::CXXDynamicCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Decl>(mx::Decl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExplicitCastExpr>>(gap::generator<mx::ExplicitCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCProtocolDecl>>(gap::generator<mx::ObjCProtocolDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCImplDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCImplDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftBridgeAttr>(mx::SwiftBridgeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RecordMemberOp>(mx::ir::hl::RecordMemberOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetExitDataDirective>(mx::OMPTargetExitDataDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSStructAttr>>(std::optional<mx::MSStructAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoMips16AttrSpelling>(mx::NoMips16AttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeNullableResultAttr>(mx::TypeNullableResultAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExtendArgsKind>(mx::ExtendArgsKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SEHFinallyStmt>>(std::optional<mx::SEHFinallyStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoProfileFunctionAttrSpelling>(mx::NoProfileFunctionAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeNullableResultAttr>>(gap::generator<mx::TypeNullableResultAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FPEvalMethodKind>(mx::FPEvalMethodKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RecordMemberOp>>(std::optional<mx::ir::hl::RecordMemberOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAttrAttr>(mx::SwiftAttrAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SEHFinallyStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::SEHFinallyStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelSectionsDirective>(mx::OMPParallelSectionsDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FastCallAttr>(mx::FastCallAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TokenTokenTreeNode>>(std::optional<mx::TokenTokenTreeNode>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FastCallAttr>>(gap::generator<mx::FastCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoRandomizeLayoutAttrSpelling>(mx::NoRandomizeLayoutAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExplicitCastExpr>>(std::optional<mx::ExplicitCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FPExceptionModeKind>(mx::FPExceptionModeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RemFOp>(mx::ir::hl::RemFOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ChoiceTokenTreeNode>>(std::optional<mx::ChoiceTokenTreeNode>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RemFAssignOp>(mx::ir::hl::RemFAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncNameAttr>(mx::SwiftAsyncNameAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ExplicitCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ExplicitCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetEnterDataDirective>(mx::OMPTargetEnterDataDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RemFAssignOp>>(std::optional<mx::ir::hl::RemFAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPSimdDirective>>(std::optional<mx::OMPSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeNullableResultAttr>>(std::optional<mx::TypeNullableResultAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::Fragment, mx::TokenTreeNode>>>(gap::generator<std::pair<mx::Fragment, mx::TokenTreeNode>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSP430InterruptAttr>(mx::MSP430InterruptAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoReturnAttrSpelling>(mx::NoReturnAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSInheritanceAttr>>(gap::generator<mx::MSInheritanceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FPModeKind>(mx::FPModeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSP430InterruptAttr>>(gap::generator<mx::MSP430InterruptAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroVAOptArgument>>(gap::generator<mx::MacroVAOptArgument>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LifetimeExtendedTemporaryDecl>(mx::LifetimeExtendedTemporaryDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncErrorAttr>(mx::SwiftAsyncErrorAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LifetimeExtendedTemporaryDecl>>(std::optional<mx::LifetimeExtendedTemporaryDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetDirective>(mx::OMPTargetDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LifetimeExtendedTemporaryDecl>>(gap::generator<mx::LifetimeExtendedTemporaryDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstitutionTokenTreeNode>>(std::optional<mx::SubstitutionTokenTreeNode>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FastCallAttr>>(std::optional<mx::FastCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoSanitizeAttrSpelling>(mx::NoSanitizeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RemFOp>>(std::optional<mx::ir::hl::RemFOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Flags>(mx::Flags) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSP430InterruptAttr>>(std::optional<mx::MSP430InterruptAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<uint64_t>>(std::optional<uint64_t>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeNullableAttr>(mx::TypeNullableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoSpeculativeLoadHardeningAttrSpelling>(mx::NoSpeculativeLoadHardeningAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeNonNullAttr>(mx::TypeNonNullAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GC>(mx::GC) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyImplDecl>(mx::ObjCPropertyImplDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncCallAttr>(mx::SwiftAsyncCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeNullableAttr>>(gap::generator<mx::TypeNullableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetDataDirective>(mx::OMPTargetDataDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCPropertyImplDecl>>(std::optional<mx::ObjCPropertyImplDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMasterTaskLoopSimdDirective>>(gap::generator<mx::OMPParallelMasterTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCPropertyImplDecl>>(gap::generator<mx::ObjCPropertyImplDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoSplitStackAttrSpelling>(mx::NoSplitStackAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RemSOp>(mx::ir::hl::RemSOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GCMode>(mx::GCMode) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExclusiveTrylockFunctionAttr>(mx::ExclusiveTrylockFunctionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMasterTaskLoopSimdDirective>>(std::optional<mx::OMPParallelMasterTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::LifetimeExtendedTemporaryDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::LifetimeExtendedTemporaryDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncAttr>(mx::SwiftAsyncAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RemSAssignOp>(mx::ir::hl::RemSAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPSingleDirective>(mx::OMPSingleDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ErrorAttr>(mx::ErrorAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TokenRange>>(std::optional<mx::TokenRange>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExclusiveTrylockFunctionAttr>>(gap::generator<mx::ExclusiveTrylockFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TokenTreeNode>>(gap::generator<mx::TokenTreeNode>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RemSAssignOp>>(std::optional<mx::ir::hl::RemSAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SequenceTokenTreeNode>>(std::optional<mx::SequenceTokenTreeNode>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCForCollectionStmt>(mx::ObjCForCollectionStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoStackProtectorAttrSpelling>(mx::NoStackProtectorAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SEHLeaveStmt>>(gap::generator<mx::SEHLeaveStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GPUDefaultStreamKind>(mx::GPUDefaultStreamKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXNamedCastExpr>(mx::CXXNamedCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<std::string_view>>(std::optional<std::string_view>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeNullableAttr>>(std::optional<mx::TypeNullableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Stmt>(mx::Stmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXConstCastExpr>(mx::CXXConstCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StrictGuardStackCheckAttr>(mx::StrictGuardStackCheckAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXNamedCastExpr>>(gap::generator<mx::CXXNamedCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPSectionsDirective>(mx::OMPSectionsDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSNoVTableAttr>(mx::MSNoVTableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoThreadSafetyAnalysisAttrSpelling>(mx::NoThreadSafetyAnalysisAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSConstexprAttr>(mx::MSConstexprAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GVALinkage>(mx::GVALinkage) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSNoVTableAttr>>(gap::generator<mx::MSNoVTableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroVAOptArgument>>(std::optional<mx::MacroVAOptArgument>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCPropertyImplDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCPropertyImplDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoThrowAttrSpelling>(mx::NoThrowAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExclusiveTrylockFunctionAttr>>(std::optional<mx::ExclusiveTrylockFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GetBuiltinTypeError>(mx::GetBuiltinTypeError) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RemSOp>>(std::optional<mx::ir::hl::RemSOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StrictFPAttr>(mx::StrictFPAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SEHLeaveStmt>>(std::optional<mx::SEHLeaveStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPSectionDirective>(mx::OMPSectionDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXNamedCastExpr>>(std::optional<mx::CXXNamedCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMasterTaskLoopDirective>>(gap::generator<mx::OMPParallelMasterTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SEHLeaveStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::SEHLeaveStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroExpansion>>(gap::generator<mx::MacroExpansion>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeNullUnspecifiedAttr>(mx::TypeNullUnspecifiedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMasterTaskLoopDirective>>(std::optional<mx::OMPParallelMasterTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ThreadAttr>(mx::ThreadAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoUniqueAddressAttrSpelling>(mx::NoUniqueAddressAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeNullUnspecifiedAttr>>(gap::generator<mx::TypeNullUnspecifiedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLLangStd>(mx::HLSLLangStd) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSNoVTableAttr>>(std::optional<mx::MSNoVTableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RegexQueryMatch>>(gap::generator<mx::RegexQueryMatch>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXNamedCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXNamedCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StdCallAttr>(mx::StdCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RemUOp>(mx::ir::hl::RemUOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPScopeDirective>(mx::OMPScopeDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RemUAssignOp>(mx::ir::hl::RemUAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroConcatenate>>(gap::generator<mx::MacroConcatenate>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RemUAssignOp>>(std::optional<mx::ir::hl::RemUAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoUwtableAttrSpelling>(mx::NoUwtableAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExcludeFromExplicitInstantiationAttr>(mx::ExcludeFromExplicitInstantiationAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ID>(mx::ID) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnumExtensibilityAttr>(mx::EnumExtensibilityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMaskedTaskLoopSimdDirective>>(gap::generator<mx::OMPParallelMaskedTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExcludeFromExplicitInstantiationAttr>>(gap::generator<mx::ExcludeFromExplicitInstantiationAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StandaloneDebugAttr>(mx::StandaloneDebugAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeNullUnspecifiedAttr>>(std::optional<mx::TypeNullUnspecifiedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPScanDirective>(mx::OMPScanDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ReturnOp>(mx::ir::hl::ReturnOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Compilation>(mx::Compilation) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSPropertySubscriptExpr>(mx::MSPropertySubscriptExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NonNullAttrSpelling>(mx::NonNullAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSInheritanceAttr>(mx::MSInheritanceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IdentifierInfoFlag>(mx::IdentifierInfoFlag) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LambdaExpr>(mx::LambdaExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroConcatenate>>(std::optional<mx::MacroConcatenate>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSPropertySubscriptExpr>>(gap::generator<mx::MSPropertySubscriptExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroStringify>>(gap::generator<mx::MacroStringify>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RemUOp>>(std::optional<mx::ir::hl::RemUOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMaskedTaskLoopSimdDirective>>(std::optional<mx::OMPParallelMaskedTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSAllocatorAttr>(mx::MSAllocatorAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NotTailCalledAttrSpelling>(mx::NotTailCalledAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AnnotateAttrSpelling>(mx::AnnotateAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IfStatementKind>(mx::IfStatementKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AnnotateTypeAttrSpelling>(mx::AnnotateTypeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SpeculativeLoadHardeningAttr>(mx::SpeculativeLoadHardeningAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCTypeParamDecl>(mx::ObjCTypeParamDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMasterDirective>(mx::OMPParallelMasterDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AnyX86InterruptAttrSpelling>(mx::AnyX86InterruptAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroStringify>>(std::optional<mx::MacroStringify>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AnyX86NoCallerSavedRegistersAttrSpelling>(mx::AnyX86NoCallerSavedRegistersAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPAllocateDeclAttrAllocatorTypeTy>(mx::OMPAllocateDeclAttrAllocatorTypeTy) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::NoProfileInstrumentFunctionAttr>>(std::optional<mx::ir::hl::NoProfileInstrumentFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ImplicitParamKind>(mx::ImplicitParamKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCTypeParamDecl>>(gap::generator<mx::ObjCTypeParamDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SharedTrylockFunctionAttr>(mx::SharedTrylockFunctionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AnyX86NoCfCheckAttrSpelling>(mx::AnyX86NoCfCheckAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMaskedDirective>(mx::OMPParallelMaskedDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDistributeParallelForSimdDirective>>(std::optional<mx::OMPTargetTeamsDistributeParallelForSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DefineMacroDirective>>(gap::generator<mx::DefineMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArcWeakrefUnavailableAttrSpelling>(mx::ArcWeakrefUnavailableAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareSimdDeclAttrBranchStateTy>(mx::OMPDeclareSimdDeclAttrBranchStateTy) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AsmLabelAttr>(mx::ir::hl::AsmLabelAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InClassInitStyle>(mx::InClassInitStyle) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArgumentWithTypeTagAttrSpelling>(mx::ArgumentWithTypeTagAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroExpansion>>(std::optional<mx::MacroExpansion>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmBuiltinAliasAttrSpelling>(mx::ArmBuiltinAliasAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroDirective>>(gap::generator<mx::MacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetTeamsDistributeParallelForSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetTeamsDistributeParallelForSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SetTypestateAttr>(mx::SetTypestateAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmMveStrictPolymorphismAttrSpelling>(mx::ArmMveStrictPolymorphismAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelDirective>(mx::OMPParallelDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeAliasDecl>>(std::optional<mx::TypeAliasDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareTargetDeclAttrDevTypeTy>(mx::OMPDeclareTargetDeclAttrDevTypeTy) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AsmLabelAttr>>(std::optional<mx::ir::hl::AsmLabelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InheritedDesignatedInitializersState>(mx::InheritedDesignatedInitializersState) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArtificialAttrSpelling>(mx::ArtificialAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMaskedTaskLoopDirective>>(gap::generator<mx::OMPParallelMaskedTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AsmLabelAttrSpelling>(mx::AsmLabelAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroArgument>>(gap::generator<mx::MacroArgument>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AssertCapabilityAttrSpelling>(mx::AssertCapabilityAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMaskedTaskLoopDirective>>(std::optional<mx::OMPParallelMaskedTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TypeAliasDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TypeAliasDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroDirective>>(std::optional<mx::MacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ModeAttr>(mx::ir::hl::ModeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareTargetDeclAttrMapTypeTy>(mx::OMPDeclareTargetDeclAttrMapTypeTy) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AssumeAlignedAttrSpelling>(mx::AssumeAlignedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InitStorageKind>(mx::InitStorageKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDADeviceBuiltinTextureTypeAttr>>(gap::generator<mx::CUDADeviceBuiltinTextureTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SentinelAttr>(mx::SentinelAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AssumptionAttrSpelling>(mx::AssumptionAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPOrderedDirective>(mx::OMPOrderedDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AtomicExprAtomicOp>(mx::AtomicExprAtomicOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroArgument>>(std::optional<mx::MacroArgument>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCTypeParamDecl>>(std::optional<mx::ObjCTypeParamDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSConsumedAttrSpelling>(mx::OSConsumedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ModeAttr>>(std::optional<mx::ir::hl::ModeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InlineVariableDefinitionKind>(mx::InlineVariableDefinitionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AvailabilityAttrSpelling>(mx::AvailabilityAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DefineMacroDirective>>(std::optional<mx::DefineMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SpeculativeLoadHardeningAttr>>(gap::generator<mx::SpeculativeLoadHardeningAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SelectAnyAttr>(mx::SelectAnyAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AvailableOnlyInDefaultEvalMethodAttrSpelling>(mx::AvailableOnlyInDefaultEvalMethodAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPMetaDirective>(mx::OMPMetaDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BuiltinAttr>(mx::ir::hl::BuiltinAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSConsumesThisAttrSpelling>(mx::OSConsumesThisAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BPFPreserveAccessIndexAttrSpelling>(mx::BPFPreserveAccessIndexAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InterestingIdentifierKind>(mx::InterestingIdentifierKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BPFPreserveStaticOffsetAttrSpelling>(mx::BPFPreserveStaticOffsetAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelGenericLoopDirective>>(gap::generator<mx::OMPParallelGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCTypeParamDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCTypeParamDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SectionAttr>(mx::SectionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BTFDeclTagAttrSpelling>(mx::BTFDeclTagAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPMasterDirective>(mx::OMPMasterDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BTFTypeTagAttrSpelling>(mx::BTFTypeTagAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelGenericLoopDirective>>(std::optional<mx::OMPParallelGenericLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BuiltinAttr>>(std::optional<mx::ir::hl::BuiltinAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsNotRetainedAttrSpelling>(mx::OSReturnsNotRetainedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BlocksAttrBlockType>(mx::BlocksAttrBlockType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Kinds>(mx::Kinds) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BlocksAttrSpelling>(mx::BlocksAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AArch64VectorPcsAttrSpelling>(mx::AArch64VectorPcsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BuiltinAliasAttrSpelling>(mx::BuiltinAliasAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OtherMacroDirective>>(gap::generator<mx::OtherMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDADeviceBuiltinTextureTypeAttr>>(std::optional<mx::CUDADeviceBuiltinTextureTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedAttrSpelling>(mx::OSReturnsRetainedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BuiltinTypeKind>(mx::BuiltinTypeKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LambdaCaptureDefault>(mx::LambdaCaptureDefault) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AllocAlignAttr>(mx::ir::hl::AllocAlignAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ScopedLockableAttr>(mx::ScopedLockableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CDeclAttrSpelling>(mx::CDeclAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPMaskedDirective>(mx::OMPMaskedDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFAuditedTransferAttrSpelling>(mx::CFAuditedTransferAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroParameterSubstitution>>(gap::generator<mx::MacroParameterSubstitution>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SpeculativeLoadHardeningAttr>>(std::optional<mx::SpeculativeLoadHardeningAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroParameterSubstitution>>(std::optional<mx::MacroParameterSubstitution>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AllocAlignAttr>>(std::optional<mx::ir::hl::AllocAlignAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedOnNonZeroAttrSpelling>(mx::OSReturnsRetainedOnNonZeroAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AllocSizeAttr>(mx::ir::hl::AllocSizeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LambdaCaptureKind>(mx::LambdaCaptureKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDependentScopeMemberExpr>>(gap::generator<mx::CXXDependentScopeMemberExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<std::string_view>>(gap::generator<std::string_view>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AllocSizeAttr>>(std::optional<mx::ir::hl::AllocSizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUFlatWorkGroupSizeAttrSpelling>(mx::AMDGPUFlatWorkGroupSizeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDistributeParallelForDirective>>(gap::generator<mx::OMPTargetTeamsDistributeParallelForDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SYCLSpecialClassAttr>(mx::SYCLSpecialClassAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DeprecatedAttr>(mx::ir::hl::DeprecatedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPLoopBasedDirective>(mx::OMPLoopBasedDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDADeviceBuiltinSurfaceTypeAttr>>(gap::generator<mx::CUDADeviceBuiltinSurfaceTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelForSimdDirective>>(gap::generator<mx::OMPParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeAliasTemplateDecl>(mx::TypeAliasTemplateDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::IncludePathLocation, std::filesystem::path>>>(gap::generator<std::pair<mx::IncludePathLocation, std::filesystem::path>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DeprecatedAttr>>(std::optional<mx::ir::hl::DeprecatedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroParameter>>(gap::generator<mx::MacroParameter>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFConsumedAttrSpelling>(mx::CFConsumedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedOnZeroAttrSpelling>(mx::OSReturnsRetainedOnZeroAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFGuardAttrGuardArg>(mx::CFGuardAttrGuardArg) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LangAS>(mx::LangAS) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFGuardAttrSpelling>(mx::CFGuardAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelForSimdDirective>>(std::optional<mx::OMPParallelForSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeAliasTemplateDecl>>(std::optional<mx::TypeAliasTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AliasAttrSpelling>(mx::AliasAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFICanonicalJumpTableAttrSpelling>(mx::CFICanonicalJumpTableAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SYCLKernelAttr>(mx::SYCLKernelAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::MaxFieldAlignmentAttr>(mx::ir::hl::MaxFieldAlignmentAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPLoopTransformationDirective>(mx::OMPLoopTransformationDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SharedTrylockFunctionAttr>>(gap::generator<mx::SharedTrylockFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBoxableAttrSpelling>(mx::ObjCBoxableAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDependentScopeMemberExpr>>(std::optional<mx::CXXDependentScopeMemberExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LangFeatures>(mx::LangFeatures) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeAliasTemplateDecl>>(gap::generator<mx::TypeAliasTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroParameter>>(std::optional<mx::MacroParameter>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFReturnsNotRetainedAttrSpelling>(mx::CFReturnsNotRetainedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaMacroDirective>>(gap::generator<mx::PragmaMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFReturnsRetainedAttrSpelling>(mx::CFReturnsRetainedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUNumSGPRAttrSpelling>(mx::AMDGPUNumSGPRAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::MaxFieldAlignmentAttr>>(std::optional<mx::ir::hl::MaxFieldAlignmentAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlignedAttrSpelling>(mx::AlignedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFUnknownTransferAttrSpelling>(mx::CFUnknownTransferAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeAttrSpelling>(mx::ObjCBridgeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CPUDispatchAttrSpelling>(mx::CPUDispatchAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Language>(mx::Language) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXDependentScopeMemberExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXDependentScopeMemberExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReturnsTwiceAttr>(mx::ReturnsTwiceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CPUSpecificAttrSpelling>(mx::CPUSpecificAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPUnrollDirective>(mx::OMPUnrollDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDistributeParallelForDirective>>(std::optional<mx::OMPTargetTeamsDistributeParallelForDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelForDirective>>(gap::generator<mx::OMPParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDAConstantAttrSpelling>(mx::CUDAConstantAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaMacroDirective>>(std::optional<mx::PragmaMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::VisibilityAttr>(mx::ir::hl::VisibilityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeMutableAttrSpelling>(mx::ObjCBridgeMutableAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceAttrSpelling>(mx::CUDADeviceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LanguageLinkage>(mx::LanguageLinkage) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling>(mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelForDirective>>(std::optional<mx::OMPParallelForDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDADeviceBuiltinSurfaceTypeAttr>>(std::optional<mx::CUDADeviceBuiltinSurfaceTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReturnsNonNullAttr>(mx::ReturnsNonNullAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetTeamsDistributeParallelForDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetTeamsDistributeParallelForDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTileDirective>(mx::OMPTileDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceBuiltinTextureTypeAttrSpelling>(mx::CUDADeviceBuiltinTextureTypeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UndefineMacroDirective>>(gap::generator<mx::UndefineMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::VisibilityAttr>>(std::optional<mx::ir::hl::VisibilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUNumVGPRAttrSpelling>(mx::AMDGPUNumVGPRAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDAGlobalAttrSpelling>(mx::CUDAGlobalAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeRelatedAttrSpelling>(mx::ObjCBridgeRelatedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCObjectType>>(gap::generator<mx::ObjCObjectType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LaxVectorConversionKind>(mx::LaxVectorConversionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AssumeAlignedAttr>(mx::ir::hl::AssumeAlignedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UndefineMacroDirective>>(std::optional<mx::UndefineMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDAHostAttrSpelling>(mx::CUDAHostAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReturnTypestateAttr>(mx::ReturnTypestateAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SharedTrylockFunctionAttr>>(std::optional<mx::SharedTrylockFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPLoopDirective>(mx::OMPLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDALaunchBoundsAttrSpelling>(mx::CUDALaunchBoundsAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OtherMacroDirective>>(std::optional<mx::OtherMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDASharedAttrSpelling>(mx::CUDASharedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCClassStubAttrSpelling>(mx::ObjCClassStubAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXX11NoReturnAttrSpelling>(mx::CXX11NoReturnAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Level>(mx::Level) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AssumeAlignedAttr>>(std::optional<mx::ir::hl::AssumeAlignedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Fragment>>(std::optional<mx::Fragment>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXRecordDeclLambdaDependencyKind>(mx::CXXRecordDeclLambdaDependencyKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCDesignatedInitializerAttrSpelling>(mx::ObjCDesignatedInitializerAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TypeAliasTemplateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TypeAliasTemplateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Linkage>(mx::Linkage) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CallExprADLCallKind>(mx::CallExprADLCallKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RetainAttr>(mx::RetainAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CVQualifiersAttr>(mx::ir::hl::CVQualifiersAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPGenericLoopDirective>(mx::OMPGenericLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CallableWhenAttrConsumedState>(mx::CallableWhenAttrConsumedState) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMasterTaskLoopSimdDirective>>(gap::generator<mx::OMPMasterTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCObjectType>>(std::optional<mx::ObjCObjectType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCDirectAttrSpelling>(mx::ObjCDirectAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CallableWhenAttrSpelling>(mx::CallableWhenAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LinkageSpecLanguageIDs>(mx::LinkageSpecLanguageIDs) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CVQualifiersAttr>>(std::optional<mx::ir::hl::CVQualifiersAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EndIfMacroDirective>>(gap::generator<mx::EndIfMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CallbackAttrSpelling>(mx::CallbackAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RestrictAttr>(mx::RestrictAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceAttr>(mx::CUDADeviceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPForSimdDirective>(mx::OMPForSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CalledOnceAttrSpelling>(mx::CalledOnceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMasterTaskLoopSimdDirective>>(std::optional<mx::OMPMasterTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CapabilityAttrSpelling>(mx::CapabilityAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Fragment>(mx::Fragment) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDADeviceAttr>>(gap::generator<mx::CUDADeviceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<SpecificEntityId<FragmentId>>>(std::optional<SpecificEntityId<FragmentId>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CapturedStmtVariableCaptureKind>(mx::CapturedStmtVariableCaptureKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConditionalMacroDirective>>(gap::generator<mx::ConditionalMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::UCVQualifiersAttr>(mx::ir::hl::UCVQualifiersAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCDirectMembersAttrSpelling>(mx::ObjCDirectMembersAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CarriesDependencyAttrSpelling>(mx::CarriesDependencyAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSInheritanceModel>(mx::MSInheritanceModel) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CleanupAttrSpelling>(mx::CleanupAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConditionalMacroDirective>>(std::optional<mx::ConditionalMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SetTypestateAttr>(mx::SetTypestateAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EndIfMacroDirective>>(std::optional<mx::EndIfMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::UCVQualifiersAttr>>(std::optional<mx::ir::hl::UCVQualifiersAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RequiresCapabilityAttr>(mx::RequiresCapabilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SetTypestateAttr>>(gap::generator<mx::SetTypestateAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPForDirective>(mx::OMPForDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CodeAlignAttrSpelling>(mx::CodeAlignAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCExceptionAttrSpelling>(mx::ObjCExceptionAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CodeModelAttrSpelling>(mx::CodeModelAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSVCMajorVersion>(mx::MSVCMajorVersion) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ColdAttrSpelling>(mx::ColdAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElseMacroDirective>>(gap::generator<mx::ElseMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CommonAttrSpelling>(mx::CommonAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCExplicitProtocolImplAttrSpelling>(mx::ObjCExplicitProtocolImplAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CVRQualifiersAttr>(mx::ir::hl::CVRQualifiersAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSVtorDispMode>(mx::MSVtorDispMode) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstAttrSpelling>(mx::ConstAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReqdWorkGroupSizeAttr>(mx::ReqdWorkGroupSizeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstInitAttrSpelling>(mx::ConstInitAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDistributeSimdDirective>(mx::OMPDistributeSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CVRQualifiersAttr>>(std::optional<mx::ir::hl::CVRQualifiersAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMasterTaskLoopDirective>>(gap::generator<mx::OMPMasterTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstructorAttrSpelling>(mx::ConstructorAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMasterTaskLoopDirective>>(std::optional<mx::OMPMasterTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAttrConsumedState>(mx::ConsumableAttrConsumedState) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElseMacroDirective>>(std::optional<mx::ElseMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDADeviceAttr>>(std::optional<mx::CUDADeviceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroVAOptArgument>(mx::MacroVAOptArgument) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAttrSpelling>(mx::ConsumableAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TransparentUnionAttr>>(gap::generator<mx::TransparentUnionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAutoCastAttrSpelling>(mx::ConsumableAutoCastAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PreserveMostAttr>>(std::optional<mx::PreserveMostAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::Type>(mx::ir::hl::Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PreserveAllAttr>>(gap::generator<mx::PreserveAllAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDistributeDirective>>(gap::generator<mx::OMPTargetTeamsDistributeDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroConcatenate>(mx::MacroConcatenate) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::OffsetOfNodeAttr>(mx::ir::hl::OffsetOfNodeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TransparentUnionAttr>>(std::optional<mx::TransparentUnionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConsumableSetOnReadAttrSpelling>(mx::ConsumableSetOnReadAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElseIfNotDefinedMacroDirective>>(gap::generator<mx::ElseIfNotDefinedMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SetTypestateAttr>>(std::optional<mx::SetTypestateAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElseIfNotDefinedMacroDirective>>(std::optional<mx::ElseIfNotDefinedMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXDefaultArgExpr>(mx::CXXDefaultArgExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroStringify>(mx::MacroStringify) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConvergentAttrSpelling>(mx::ConvergentAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PreserveAllAttr>>(std::optional<mx::PreserveAllAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDeleteExpr>>(gap::generator<mx::CXXDeleteExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ThisCallAttr>>(std::optional<mx::ThisCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroDisableLifetimeBoundAttrSpelling>(mx::CoroDisableLifetimeBoundAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TestTypestateAttr>>(gap::generator<mx::TestTypestateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::OffsetOfNodeAttr>>(std::optional<mx::ir::hl::OffsetOfNodeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroExpansion>(mx::MacroExpansion) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroLifetimeBoundAttrSpelling>(mx::CoroLifetimeBoundAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElseIfDefinedMacroDirective>>(gap::generator<mx::ElseIfDefinedMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroOnlyDestroyWhenCompleteAttrSpelling>(mx::CoroOnlyDestroyWhenCompleteAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PreferredTypeAttr>>(std::optional<mx::PreferredTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroReturnTypeAttrSpelling>(mx::CoroReturnTypeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WhileStmt>>(gap::generator<mx::WhileStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCInterfaceType>>(gap::generator<mx::ObjCInterfaceType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Macro>(mx::Macro) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroWrapperAttrSpelling>(mx::CoroWrapperAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElseIfDefinedMacroDirective>>(std::optional<mx::ElseIfDefinedMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::Type>>(std::optional<mx::ir::hl::Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PreferredNameAttr>>(gap::generator<mx::PreferredNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LinkageSpecDecl>(mx::LinkageSpecDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElseIfMacroDirective>>(gap::generator<mx::ElseIfMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CountedByAttrSpelling>(mx::CountedByAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroArgument>(mx::MacroArgument) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinTemplateDecl>>(gap::generator<mx::BuiltinTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TestTypestateAttr>>(std::optional<mx::TestTypestateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DLLExportAttrSpelling>(mx::DLLExportAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WhileStmt>>(std::optional<mx::WhileStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DLLImportAttrSpelling>(mx::DLLImportAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TargetVersionAttr>>(gap::generator<mx::TargetVersionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeclFriendObjectKind>(mx::DeclFriendObjectKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElseIfMacroDirective>>(std::optional<mx::ElseIfMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDAConstantAttr>(mx::CUDAConstantAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PreferredNameAttr>>(std::optional<mx::PreferredNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RecordType>(mx::ir::hl::RecordType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroParameterSubstitution>(mx::MacroParameterSubstitution) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeclIdentifierNamespace>(mx::DeclIdentifierNamespace) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IfMacroDirective>>(gap::generator<mx::IfMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDistributeDirective>>(std::optional<mx::OMPTargetTeamsDistributeDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PointerAttr>>(gap::generator<mx::PointerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAConstantAttr>>(gap::generator<mx::CUDAConstantAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TargetVersionAttr>>(std::optional<mx::TargetVersionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeclModuleOwnershipKind>(mx::DeclModuleOwnershipKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IfNotDefinedMacroDirective>>(gap::generator<mx::IfNotDefinedMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCInterfaceType>>(std::optional<mx::ObjCInterfaceType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroParameter>(mx::MacroParameter) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDeleteExpr>>(std::optional<mx::CXXDeleteExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TargetClonesAttr>>(gap::generator<mx::TargetClonesAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RecordType>>(std::optional<mx::ir::hl::RecordType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DesignatedInitExpr>>(gap::generator<mx::DesignatedInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeclObjCDeclQualifier>(mx::DeclObjCDeclQualifier) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IfNotDefinedMacroDirective>>(std::optional<mx::IfNotDefinedMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetTeamsDistributeDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetTeamsDistributeDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DesignatedInitUpdateExpr>>(gap::generator<mx::DesignatedInitUpdateExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SentinelAttr>(mx::SentinelAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IfDefinedMacroDirective>>(gap::generator<mx::IfDefinedMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SentinelAttr>>(gap::generator<mx::SentinelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaMacroDirective>(mx::PragmaMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXDeleteExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXDeleteExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangTextSectionAttr>>(gap::generator<mx::PragmaClangTextSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinTemplateDecl>>(std::optional<mx::BuiltinTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DesignatedInitUpdateExpr>>(std::optional<mx::DesignatedInitUpdateExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::EnumType>(mx::ir::hl::EnumType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TargetClonesAttr>>(std::optional<mx::TargetClonesAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeprecatedAttrSpelling>(mx::DeprecatedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangTextSectionAttr>>(std::optional<mx::PragmaClangTextSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DestructorAttrSpelling>(mx::DestructorAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IfDefinedMacroDirective>>(std::optional<mx::IfDefinedMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::EnumType>>(std::optional<mx::ir::hl::EnumType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TargetAttr>>(gap::generator<mx::TargetAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::BuiltinTemplateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::BuiltinTemplateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UndefineMacroDirective>(mx::UndefineMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAConstantAttr>>(std::optional<mx::CUDAConstantAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InitListExpr>>(gap::generator<mx::InitListExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DiagnoseAsBuiltinAttrSpelling>(mx::DiagnoseAsBuiltinAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangRodataSectionAttr>>(gap::generator<mx::PragmaClangRodataSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TypedefType>(mx::ir::hl::TypedefType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IfMacroDirective>>(std::optional<mx::IfMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DiagnoseIfAttrDiagnosticType>(mx::DiagnoseIfAttrDiagnosticType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OtherMacroDirective>(mx::OtherMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DisableSanitizerInstrumentationAttrSpelling>(mx::DisableSanitizerInstrumentationAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TargetAttr>>(std::optional<mx::TargetAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DisableTailCallsAttrSpelling>(mx::DisableTailCallsAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangRodataSectionAttr>>(std::optional<mx::PragmaClangRodataSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCObjectPointerType>(mx::ObjCObjectPointerType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TLSModelAttr>>(gap::generator<mx::TLSModelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SentinelAttr>>(std::optional<mx::SentinelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InitListExpr>>(std::optional<mx::InitListExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TypedefType>>(std::optional<mx::ir::hl::TypedefType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConditionalMacroDirective>(mx::ConditionalMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCObjectPointerType>>(gap::generator<mx::ObjCObjectPointerType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangRelroSectionAttr>>(gap::generator<mx::PragmaClangRelroSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnforceTCBAttrSpelling>(mx::EnforceTCBAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncludeLikeMacroDirective>>(gap::generator<mx::IncludeLikeMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnforceTCBLeafAttrSpelling>(mx::EnforceTCBLeafAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TLSModelAttr>>(std::optional<mx::TLSModelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnumExtensibilityAttrKind>(mx::EnumExtensibilityAttrKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangRelroSectionAttr>>(std::optional<mx::PragmaClangRelroSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnumExtensibilityAttrSpelling>(mx::EnumExtensibilityAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EndIfMacroDirective>(mx::EndIfMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ElaboratedType>(mx::ir::hl::ElaboratedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncludeLikeMacroDirective>>(std::optional<mx::IncludeLikeMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ErrorAttrSpelling>(mx::ErrorAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SysVABIAttr>>(gap::generator<mx::SysVABIAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ElaboratedType>>(std::optional<mx::ir::hl::ElaboratedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImportMacroDirective>>(gap::generator<mx::ImportMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCObjectPointerType>>(std::optional<mx::ObjCObjectPointerType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ElseMacroDirective>(mx::ElseMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExcludeFromExplicitInstantiationAttrSpelling>(mx::ExcludeFromExplicitInstantiationAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangDataSectionAttr>>(gap::generator<mx::PragmaClangDataSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprConstantExprKind>(mx::ExprConstantExprKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImportMacroDirective>>(std::optional<mx::ImportMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LabelType>(mx::ir::hl::LabelType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SysVABIAttr>>(std::optional<mx::SysVABIAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprLValueClassification>(mx::ExprLValueClassification) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangDataSectionAttr>>(std::optional<mx::PragmaClangDataSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CPUSpecificAttr>(mx::CPUSpecificAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftPrivateAttr>>(gap::generator<mx::SwiftPrivateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprNullPointerConstantKind>(mx::ExprNullPointerConstantKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ElseIfNotDefinedMacroDirective>(mx::ElseIfNotDefinedMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFReturnsNotRetainedAttr>(mx::CFReturnsNotRetainedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RedeclarableTemplateDecl>>(std::optional<mx::RedeclarableTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CPUSpecificAttr>>(gap::generator<mx::CPUSpecificAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncludeMacrosMacroDirective>>(gap::generator<mx::IncludeMacrosMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprNullPointerConstantValueDependence>(mx::ExprNullPointerConstantValueDependence) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangBSSSectionAttr>>(gap::generator<mx::PragmaClangBSSSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LabelType>>(std::optional<mx::ir::hl::LabelType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncludeMacrosMacroDirective>>(std::optional<mx::IncludeMacrosMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprSideEffectsKind>(mx::ExprSideEffectsKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ElseIfDefinedMacroDirective>(mx::ElseIfDefinedMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SelectAnyAttr>(mx::SelectAnyAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftPrivateAttr>>(std::optional<mx::SwiftPrivateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ParenType>(mx::ir::hl::ParenType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangBSSSectionAttr>>(std::optional<mx::PragmaClangBSSSectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprisModifiableLvalueResult>(mx::ExprisModifiableLvalueResult) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftNewTypeAttr>>(gap::generator<mx::SwiftNewTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ScopedLockableAttr>(mx::ScopedLockableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PointerAttr>>(std::optional<mx::PointerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SelectAnyAttr>>(gap::generator<mx::SelectAnyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlwaysDestroyAttrSpelling>(mx::AlwaysDestroyAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetSimdDirective>(mx::OMPTargetSimdDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DesignatedInitExpr>>(std::optional<mx::DesignatedInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetParallelForSimdDirective>(mx::OMPTargetParallelForSimdDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ElseIfMacroDirective>(mx::ElseIfMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExternalSourceSymbolAttrSpelling>(mx::ExternalSourceSymbolAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncludeNextMacroDirective>>(gap::generator<mx::IncludeNextMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetSimdDirective>>(gap::generator<mx::OMPTargetSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OwnerAttr>>(gap::generator<mx::OwnerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FallThroughAttrSpelling>(mx::FallThroughAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncludeNextMacroDirective>>(std::optional<mx::IncludeNextMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FastCallAttrSpelling>(mx::FastCallAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftNewTypeAttr>>(std::optional<mx::SwiftNewTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ParenType>>(std::optional<mx::ir::hl::ParenType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncludeMacroDirective>>(gap::generator<mx::IncludeMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FinalAttrSpelling>(mx::FinalAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IfNotDefinedMacroDirective>(mx::IfNotDefinedMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXDefaultInitExpr>(mx::CXXDefaultInitExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftNameAttr>>(gap::generator<mx::SwiftNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LValueType>(mx::ir::hl::LValueType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PcsAttr>>(gap::generator<mx::PcsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FlagEnumAttrSpelling>(mx::FlagEnumAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlwaysInlineAttrSpelling>(mx::AlwaysInlineAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXBoolLiteralExpr>(mx::CXXBoolLiteralExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncludeMacroDirective>>(std::optional<mx::IncludeMacroDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FlattenAttrSpelling>(mx::FlattenAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IfDefinedMacroDirective>(mx::IfDefinedMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDefaultInitExpr>>(gap::generator<mx::CXXDefaultInitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PcsAttr>>(std::optional<mx::PcsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FormatArgAttrSpelling>(mx::FormatArgAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoawaitExpr>>(gap::generator<mx::CoawaitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CPUSpecificAttr>>(std::optional<mx::CPUSpecificAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnnotateAttrSpelling>(mx::AnnotateAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FormatAttrSpelling>(mx::FormatAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftNameAttr>>(std::optional<mx::SwiftNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LValueType>>(std::optional<mx::ir::hl::LValueType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentScopeDeclRefExpr>>(gap::generator<mx::DependentScopeDeclRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionDeclTemplatedKind>(mx::FunctionDeclTemplatedKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentScopeDeclRefExpr>>(std::optional<mx::DependentScopeDeclRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCCompatibleAliasDecl>(mx::ObjCCompatibleAliasDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnnotateTypeAttrSpelling>(mx::AnnotateTypeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateTemplateParmDecl>>(gap::generator<mx::TemplateTemplateParmDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IfMacroDirective>(mx::IfMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionReturnThunksAttrKind>(mx::FunctionReturnThunksAttrKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PascalAttr>>(gap::generator<mx::PascalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionReturnThunksAttrSpelling>(mx::FunctionReturnThunksAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnyX86InterruptAttrSpelling>(mx::AnyX86InterruptAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RValueType>(mx::ir::hl::RValueType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PatchableFunctionEntryAttr>>(gap::generator<mx::PatchableFunctionEntryAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionTypeAArch64SMETypeAttributes>(mx::FunctionTypeAArch64SMETypeAttributes) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IncludeLikeMacroDirective>(mx::IncludeLikeMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SelectAnyAttr>>(std::optional<mx::SelectAnyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftImportPropertyAsAccessorsAttr>>(gap::generator<mx::SwiftImportPropertyAsAccessorsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetSimdDirective>>(std::optional<mx::OMPTargetSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PatchableFunctionEntryAttr>>(std::optional<mx::PatchableFunctionEntryAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RValueType>>(std::optional<mx::ir::hl::RValueType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnyX86NoCallerSavedRegistersAttrSpelling>(mx::AnyX86NoCallerSavedRegistersAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionTypeArmStateValue>(mx::FunctionTypeArmStateValue) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftImportPropertyAsAccessorsAttr>>(std::optional<mx::SwiftImportPropertyAsAccessorsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftErrorAttr>>(gap::generator<mx::SwiftErrorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GNUInlineAttrSpelling>(mx::GNUInlineAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ImportMacroDirective>(mx::ImportMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GuardedVarAttrSpelling>(mx::GuardedVarAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnyX86NoCfCheckAttrSpelling>(mx::AnyX86NoCfCheckAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::VoidType>(mx::ir::hl::VoidType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PascalAttr>>(std::optional<mx::PascalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDefaultInitExpr>>(std::optional<mx::CXXDefaultInitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentCoawaitExpr>>(gap::generator<mx::DependentCoawaitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HIPManagedAttrSpelling>(mx::HIPManagedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftImportAsNonGenericAttr>>(gap::generator<mx::SwiftImportAsNonGenericAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::VoidType>>(std::optional<mx::ir::hl::VoidType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParamTypestateAttr>>(gap::generator<mx::ParamTypestateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLParamModifierAttrSpelling>(mx::HLSLParamModifierAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArcWeakrefUnavailableAttrSpelling>(mx::ArcWeakrefUnavailableAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MemberPointerType>(mx::MemberPointerType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<EntityId>(EntityId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXDefaultInitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXDefaultInitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IncludeMacrosMacroDirective>(mx::IncludeMacrosMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateTemplateParmDecl>>(std::optional<mx::TemplateTemplateParmDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftImportAsNonGenericAttr>>(std::optional<mx::SwiftImportAsNonGenericAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLShaderAttrShaderType>(mx::HLSLShaderAttrShaderType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentCoawaitExpr>>(std::optional<mx::DependentCoawaitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentSizedMatrixType>(mx::DependentSizedMatrixType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArgumentWithTypeTagAttrSpelling>(mx::ArgumentWithTypeTagAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HotAttrSpelling>(mx::HotAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IncludeNextMacroDirective>(mx::IncludeNextMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MemberPointerType>>(gap::generator<mx::MemberPointerType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParamTypestateAttr>>(std::optional<mx::ParamTypestateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CPUDispatchAttr>(mx::CPUDispatchAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmBuiltinAliasAttrSpelling>(mx::ArmBuiltinAliasAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IBActionAttrSpelling>(mx::IBActionAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftErrorAttr>>(std::optional<mx::SwiftErrorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFReturnsRetainedAttr>(mx::CFReturnsRetainedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PackedAttr>>(gap::generator<mx::PackedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BoolType>(mx::ir::hl::BoolType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroutineSuspendExpr>>(gap::generator<mx::CoroutineSuspendExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CPUDispatchAttr>>(gap::generator<mx::CPUDispatchAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftCallAttr>>(gap::generator<mx::SwiftCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TemplateTemplateParmDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TemplateTemplateParmDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IncludeMacroDirective>(mx::IncludeMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BoolType>>(std::optional<mx::ir::hl::BoolType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmMveStrictPolymorphismAttrSpelling>(mx::ArmMveStrictPolymorphismAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SectionAttr>(mx::SectionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PackedAttr>>(std::optional<mx::PackedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SYCLSpecialClassAttr>(mx::SYCLSpecialClassAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OverloadExpr>>(gap::generator<mx::OverloadExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SectionAttr>>(gap::generator<mx::SectionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArtificialAttrSpelling>(mx::ArtificialAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CharType>(mx::ir::hl::CharType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftCallAttr>>(std::optional<mx::SwiftCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MemberPointerType>>(std::optional<mx::MemberPointerType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OwnershipAttr>>(gap::generator<mx::OwnershipAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IBOutletAttrSpelling>(mx::IBOutletAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftBridgeAttr>>(gap::generator<mx::SwiftBridgeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IBOutletCollectionAttrSpelling>(mx::IBOutletCollectionAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AsmLabelAttrSpelling>(mx::AsmLabelAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IFuncAttrSpelling>(mx::IFuncAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OverloadExpr>>(std::optional<mx::OverloadExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ImplicitCastExprOnStack>(mx::ImplicitCastExprOnStack) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftBridgedTypedefAttr>>(gap::generator<mx::SwiftBridgedTypedefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CharType>>(std::optional<mx::ir::hl::CharType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AssertCapabilityAttrSpelling>(mx::AssertCapabilityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InitPriorityAttrSpelling>(mx::InitPriorityAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OwnershipAttr>>(std::optional<mx::OwnershipAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IntelOclBiccAttrSpelling>(mx::IntelOclBiccAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftBridgedTypedefAttr>>(std::optional<mx::SwiftBridgedTypedefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ShortType>(mx::ir::hl::ShortType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AssumeAlignedAttrSpelling>(mx::AssumeAlignedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InternalLinkageAttrSpelling>(mx::InternalLinkageAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<VariantEntity>(VariantEntity) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CPUDispatchAttr>>(std::optional<mx::CPUDispatchAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OwnerAttr>>(std::optional<mx::OwnerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LTOVisibilityPublicAttrSpelling>(mx::LTOVisibilityPublicAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXBaseSpecifier>>(std::optional<mx::CXXBaseSpecifier>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::IntType>(mx::ir::hl::IntType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AssumptionAttrSpelling>(mx::AssumptionAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LeafAttrSpelling>(mx::LeafAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftBridgeAttr>>(std::optional<mx::SwiftBridgeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LifetimeBoundAttrSpelling>(mx::LifetimeBoundAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAttrAttr>>(gap::generator<mx::SwiftAttrAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ShortType>>(std::optional<mx::ir::hl::ShortType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedLookupExpr>>(gap::generator<mx::UnresolvedLookupExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LikelyAttrSpelling>(mx::LikelyAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AtomicExprAtomicOp>(mx::AtomicExprAtomicOp) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LoaderUninitializedAttrSpelling>(mx::LoaderUninitializedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OverrideAttr>>(gap::generator<mx::OverrideAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SectionAttr>>(std::optional<mx::SectionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Decl>>(std::optional<mx::Decl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LoopHintAttrLoopHintState>(mx::LoopHintAttrLoopHintState) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedLookupExpr>>(std::optional<mx::UnresolvedLookupExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LoopHintAttrOptionType>(mx::LoopHintAttrOptionType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AvailabilityAttrSpelling>(mx::AvailabilityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LoopHintAttrSpelling>(mx::LoopHintAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAttrAttr>>(std::optional<mx::SwiftAttrAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::IntType>>(std::optional<mx::ir::hl::IntType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OverrideAttr>>(std::optional<mx::OverrideAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetParallelGenericLoopDirective>(mx::OMPTargetParallelGenericLoopDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncNameAttr>>(gap::generator<mx::SwiftAsyncNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetParallelForDirective>(mx::OMPTargetParallelForDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AvailableOnlyInDefaultEvalMethodAttrSpelling>(mx::AvailableOnlyInDefaultEvalMethodAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetParallelGenericLoopDirective>>(gap::generator<mx::OMPTargetParallelGenericLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OptimizeNoneAttr>>(gap::generator<mx::OptimizeNoneAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LongType>>(std::optional<mx::ir::hl::LongType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroutineSuspendExpr>>(std::optional<mx::CoroutineSuspendExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LongType>(mx::ir::hl::LongType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedStmtId>(PackedStmtId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSABIAttrSpelling>(mx::MSABIAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BPFPreserveAccessIndexAttrSpelling>(mx::BPFPreserveAccessIndexAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MatrixType>(mx::MatrixType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncNameAttr>>(std::optional<mx::SwiftAsyncNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::M68kRTDAttrSpelling>(mx::M68kRTDAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OptimizeNoneAttr>>(std::optional<mx::OptimizeNoneAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstantMatrixType>(mx::ConstantMatrixType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BPFPreserveStaticOffsetAttrSpelling>(mx::BPFPreserveStaticOffsetAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MIGServerRoutineAttrSpelling>(mx::MIGServerRoutineAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncErrorAttr>>(gap::generator<mx::SwiftAsyncErrorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFUnknownTransferAttr>(mx::CFUnknownTransferAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLKernelAttr>>(gap::generator<mx::OpenCLKernelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MatrixType>>(gap::generator<mx::MatrixType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpaqueValueExpr>>(gap::generator<mx::OpaqueValueExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LongLongType>(mx::ir::hl::LongLongType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BTFDeclTagAttrSpelling>(mx::BTFDeclTagAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AArch64SVEPcsAttr>>(gap::generator<mx::AArch64SVEPcsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncErrorAttr>>(std::optional<mx::SwiftAsyncErrorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoreturnStmt>>(std::optional<mx::CoreturnStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLKernelAttr>>(std::optional<mx::OpenCLKernelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TokenTreeNode>(mx::TokenTreeNode) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BTFTypeTagAttrSpelling>(mx::BTFTypeTagAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TokenTreeNodeKind>(mx::TokenTreeNodeKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpaqueValueExpr>>(std::optional<mx::OpaqueValueExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CoreturnStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::CoreturnStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncCallAttr>>(gap::generator<mx::SwiftAsyncCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceAndOp>>(std::optional<mx::ir::llvm::VPReduceAndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BlocksAttrBlockType>(mx::BlocksAttrBlockType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::IntegerSetAttr>>(std::optional<mx::ir::builtin::IntegerSetAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Stmt>>(gap::generator<mx::Stmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UsingDecl>(mx::UsingDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BlocksAttrSpelling>(mx::BlocksAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::OpaqueAttr>(mx::ir::builtin::OpaqueAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncCallAttr>>(std::optional<mx::SwiftAsyncCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaDetectMismatchDecl>>(gap::generator<mx::PragmaDetectMismatchDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLIntelReqdSubGroupSizeAttr>>(gap::generator<mx::OpenCLIntelReqdSubGroupSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AArch64SVEPcsAttr>>(std::optional<mx::AArch64SVEPcsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncAttr>>(gap::generator<mx::SwiftAsyncAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::OpaqueAttr>>(std::optional<mx::ir::builtin::OpaqueAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLIntelReqdSubGroupSizeAttr>>(std::optional<mx::OpenCLIntelReqdSubGroupSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::File>>(gap::generator<mx::File>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoawaitExpr>>(std::optional<mx::CoawaitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedFileId>(PackedFileId) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BuiltinAliasAttrSpelling>(mx::BuiltinAliasAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceFAddOp>(mx::ir::llvm::VPReduceFAddOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRootClassAttr>>(gap::generator<mx::ObjCRootClassAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPSingleDirective>>(gap::generator<mx::OMPSingleDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VarDecl>>(gap::generator<mx::VarDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::SparseElementsAttr>(mx::ir::builtin::SparseElementsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::filesystem::path>(std::filesystem::path) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Fragment>>(gap::generator<mx::Fragment>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BuiltinTypeKind>(mx::BuiltinTypeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceFAddOp>>(std::optional<mx::ir::llvm::VPReduceFAddOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncAttr>>(std::optional<mx::SwiftAsyncAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::filesystem::path>>(gap::generator<std::filesystem::path>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCSubclassingRestrictedAttr>>(gap::generator<mx::ObjCSubclassingRestrictedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::SparseElementsAttr>>(std::optional<mx::ir::builtin::SparseElementsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoyieldExpr>>(gap::generator<mx::CoyieldExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaDetectMismatchDecl>>(std::optional<mx::PragmaDetectMismatchDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCSubclassingRestrictedAttr>>(std::optional<mx::ObjCSubclassingRestrictedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<FragmentIdList>(FragmentIdList) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CDeclAttrSpelling>(mx::CDeclAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::StridedLayoutAttr>(mx::ir::builtin::StridedLayoutAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StrictFPAttr>>(gap::generator<mx::StrictFPAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::PragmaDetectMismatchDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::PragmaDetectMismatchDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFAuditedTransferAttrSpelling>(mx::CFAuditedTransferAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::StridedLayoutAttr>>(std::optional<mx::ir::builtin::StridedLayoutAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoyieldExpr>>(std::optional<mx::CoyieldExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ZeroCallUsedRegsAttr>>(gap::generator<mx::ZeroCallUsedRegsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StrictGuardStackCheckAttr>>(gap::generator<mx::StrictGuardStackCheckAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceFMaxOp>(mx::ir::llvm::VPReduceFMaxOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRootClassAttr>>(std::optional<mx::ObjCRootClassAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPSingleDirective>>(std::optional<mx::OMPSingleDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFConsumedAttrSpelling>(mx::CFConsumedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceFMaxOp>>(std::optional<mx::ir::llvm::VPReduceFMaxOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StrictGuardStackCheckAttr>>(std::optional<mx::StrictGuardStackCheckAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::StringAttr>(mx::ir::builtin::StringAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConvertVectorExpr>>(gap::generator<mx::ConvertVectorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::StringAttr>>(std::optional<mx::ir::builtin::StringAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFGuardAttrGuardArg>(mx::CFGuardAttrGuardArg) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPSingleDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPSingleDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedAttrId>(PackedAttrId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXForRangeStmt>(mx::CXXForRangeStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StrictFPAttr>>(std::optional<mx::StrictFPAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ContinueStmt>>(gap::generator<mx::ContinueStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCReturnsInnerPointerAttr>>(gap::generator<mx::ObjCReturnsInnerPointerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ZeroCallUsedRegsAttr>>(std::optional<mx::ZeroCallUsedRegsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFGuardAttrSpelling>(mx::CFGuardAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceFMinOp>(mx::ir::llvm::VPReduceFMinOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StdCallAttr>>(gap::generator<mx::StdCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceFMinOp>>(std::optional<mx::ir::llvm::VPReduceFMinOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCReturnsInnerPointerAttr>>(std::optional<mx::ObjCReturnsInnerPointerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::SymbolRefAttr>(mx::ir::builtin::SymbolRefAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConvertVectorExpr>>(std::optional<mx::ConvertVectorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::SymbolRefAttr>>(std::optional<mx::ir::builtin::SymbolRefAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRequiresSuperAttr>>(gap::generator<mx::ObjCRequiresSuperAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ContinueStmt>>(std::optional<mx::ContinueStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateDecl>>(gap::generator<mx::TemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::TypeAttr>(mx::ir::builtin::TypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFICanonicalJumpTableAttrSpelling>(mx::CFICanonicalJumpTableAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ContinueStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ContinueStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedMacroId>(PackedMacroId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::TypeAttr>>(std::optional<mx::ir::builtin::TypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StdCallAttr>>(std::optional<mx::StdCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceFMulOp>(mx::ir::llvm::VPReduceFMulOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFReturnsNotRetainedAttrSpelling>(mx::CFReturnsNotRetainedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceFMulOp>>(std::optional<mx::ir::llvm::VPReduceFMulOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRequiresSuperAttr>>(std::optional<mx::ObjCRequiresSuperAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::XRayLogArgsAttr>>(gap::generator<mx::XRayLogArgsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StandaloneDebugAttr>>(gap::generator<mx::StandaloneDebugAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::UnitAttr>(mx::ir::builtin::UnitAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFReturnsRetainedAttrSpelling>(mx::CFReturnsRetainedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::UnitAttr>>(std::optional<mx::ir::builtin::UnitAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCOwnershipAttr>>(gap::generator<mx::ObjCOwnershipAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaCommentDecl>>(gap::generator<mx::PragmaCommentDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CompoundLiteralExpr>>(gap::generator<mx::CompoundLiteralExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::BoolAttr>(mx::ir::builtin::BoolAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConceptSpecializationExpr>>(gap::generator<mx::ConceptSpecializationExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPSectionsDirective>>(gap::generator<mx::OMPSectionsDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFUnknownTransferAttrSpelling>(mx::CFUnknownTransferAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::BoolAttr>>(std::optional<mx::ir::builtin::BoolAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StandaloneDebugAttr>>(std::optional<mx::StandaloneDebugAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceMulOp>(mx::ir::llvm::VPReduceMulOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRequiresPropertyDefsAttr>>(gap::generator<mx::ObjCRequiresPropertyDefsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceMulOp>>(std::optional<mx::ir::llvm::VPReduceMulOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConceptSpecializationExpr>>(std::optional<mx::ConceptSpecializationExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::XRayLogArgsAttr>>(std::optional<mx::XRayLogArgsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRequiresPropertyDefsAttr>>(std::optional<mx::ObjCRequiresPropertyDefsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::FlatSymbolRefAttr>(mx::ir::builtin::FlatSymbolRefAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CPUDispatchAttrSpelling>(mx::CPUDispatchAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaCommentDecl>>(std::optional<mx::PragmaCommentDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCPreciseLifetimeAttr>>(gap::generator<mx::ObjCPreciseLifetimeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::FlatSymbolRefAttr>>(std::optional<mx::ir::builtin::FlatSymbolRefAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PtGuardedByAttr>>(gap::generator<mx::PtGuardedByAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TokenContext>>(std::optional<mx::TokenContext>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CPUSpecificAttrSpelling>(mx::CPUSpecificAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::DenseIntElementsAttr>(mx::ir::builtin::DenseIntElementsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::string_view>(std::string_view) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPSectionsDirective>>(std::optional<mx::OMPSectionsDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SpeculativeLoadHardeningAttr>>(gap::generator<mx::SpeculativeLoadHardeningAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::PragmaCommentDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::PragmaCommentDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCPreciseLifetimeAttr>>(std::optional<mx::ObjCPreciseLifetimeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceOrOp>(mx::ir::llvm::VPReduceOrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SpeculativeLoadHardeningAttr>>(std::optional<mx::SpeculativeLoadHardeningAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TokenCategory>(mx::TokenCategory) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDAConstantAttrSpelling>(mx::CUDAConstantAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::DenseIntElementsAttr>>(std::optional<mx::ir::builtin::DenseIntElementsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SharedTrylockFunctionAttr>>(gap::generator<mx::SharedTrylockFunctionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPSectionsDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPSectionsDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceAttrSpelling>(mx::CUDADeviceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceOrOp>>(std::optional<mx::ir::llvm::VPReduceOrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCOwnershipAttr>>(std::optional<mx::ObjCOwnershipAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::DataLayoutSpecAttr>(mx::ir::builtin::DataLayoutSpecAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImplicitConceptSpecializationDecl>>(gap::generator<mx::ImplicitConceptSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Type>(mx::ir::builtin::Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SharedTrylockFunctionAttr>>(std::optional<mx::SharedTrylockFunctionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::XRayInstrumentAttr>(mx::XRayInstrumentAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCNSObjectAttr>>(gap::generator<mx::ObjCNSObjectAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXTryStmt>>(gap::generator<mx::CXXTryStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImplicitConceptSpecializationDecl>>(std::optional<mx::ImplicitConceptSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::XRayInstrumentAttr>>(gap::generator<mx::XRayInstrumentAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling>(mx::CUDADeviceBuiltinSurfaceTypeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::DataLayoutSpecAttr>>(std::optional<mx::ir::builtin::DataLayoutSpecAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SetTypestateAttr>>(gap::generator<mx::SetTypestateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<std::pair<uint32_t, uint32_t>>>(std::optional<std::pair<uint32_t, uint32_t>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceBuiltinTextureTypeAttrSpelling>(mx::CUDADeviceBuiltinTextureTypeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Type>>(std::optional<mx::ir::builtin::Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCNSObjectAttr>>(std::optional<mx::ObjCNSObjectAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceSMaxOp>(mx::ir::llvm::VPReduceSMaxOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SetTypestateAttr>>(std::optional<mx::SetTypestateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceSMaxOp>>(std::optional<mx::ir::llvm::VPReduceSMaxOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDAGlobalAttrSpelling>(mx::CUDAGlobalAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::ShapedType>(mx::ir::builtin::ShapedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedTypeId>(PackedTypeId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::ShapedType>>(std::optional<mx::ir::builtin::ShapedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SentinelAttr>>(gap::generator<mx::SentinelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXTryStmt>>(std::optional<mx::CXXTryStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCMethodFamilyAttr>>(gap::generator<mx::ObjCMethodFamilyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::XRayInstrumentAttr>>(std::optional<mx::XRayInstrumentAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDAHostAttrSpelling>(mx::CUDAHostAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXTryStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXTryStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CompoundLiteralExpr>>(std::optional<mx::CompoundLiteralExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceSMinOp>(mx::ir::llvm::VPReduceSMinOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDALaunchBoundsAttrSpelling>(mx::CUDALaunchBoundsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceSMinOp>>(std::optional<mx::ir::llvm::VPReduceSMinOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SentinelAttr>>(std::optional<mx::SentinelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::FloatType>(mx::ir::builtin::FloatType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCMethodFamilyAttr>>(std::optional<mx::ObjCMethodFamilyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::FloatType>>(std::optional<mx::ir::builtin::FloatType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedTemplateArgumentId>(PackedTemplateArgumentId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::HLSLBufferDecl>(mx::HLSLBufferDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SelectAnyAttr>>(gap::generator<mx::SelectAnyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLBufferDecl>>(gap::generator<mx::HLSLBufferDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDASharedAttrSpelling>(mx::CUDASharedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPSectionDirective>(mx::OMPSectionDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ChooseExpr>>(gap::generator<mx::ChooseExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPScanDirective>(mx::OMPScanDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIndependentClassAttr>>(gap::generator<mx::ObjCIndependentClassAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPSectionDirective>>(gap::generator<mx::OMPSectionDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXX11NoReturnAttrSpelling>(mx::CXX11NoReturnAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::ComplexType>(mx::ir::builtin::ComplexType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SelectAnyAttr>>(std::optional<mx::SelectAnyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::X86ForceAlignArgPointerAttr>(mx::X86ForceAlignArgPointerAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIndependentClassAttr>>(std::optional<mx::ObjCIndependentClassAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::ComplexType>>(std::optional<mx::ir::builtin::ComplexType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedTemplateParameterListId>(PackedTemplateParameterListId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::X86ForceAlignArgPointerAttr>>(gap::generator<mx::X86ForceAlignArgPointerAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SectionAttr>>(gap::generator<mx::SectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceUMaxOp>(mx::ir::llvm::VPReduceUMaxOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ChooseExpr>>(std::optional<mx::ChooseExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceUMaxOp>>(std::optional<mx::ir::llvm::VPReduceUMaxOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXRecordDeclLambdaDependencyKind>(mx::CXXRecordDeclLambdaDependencyKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float8E5M2Type>(mx::ir::builtin::Float8E5M2Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCExternallyRetainedAttr>>(gap::generator<mx::ObjCExternallyRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float8E5M2Type>>(std::optional<mx::ir::builtin::Float8E5M2Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CallExprADLCallKind>(mx::CallExprADLCallKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLBufferDecl>>(std::optional<mx::HLSLBufferDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SectionAttr>>(std::optional<mx::SectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPSectionDirective>>(std::optional<mx::OMPSectionDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCExternallyRetainedAttr>>(std::optional<mx::ObjCExternallyRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float8E4M3FNType>(mx::ir::builtin::Float8E4M3FNType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CharacterLiteral>>(gap::generator<mx::CharacterLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::HLSLBufferDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::HLSLBufferDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CallableWhenAttrConsumedState>(mx::CallableWhenAttrConsumedState) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TokenRange>>(std::optional<mx::TokenRange>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedCXXBaseSpecifierId>(PackedCXXBaseSpecifierId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float8E4M3FNType>>(std::optional<mx::ir::builtin::Float8E4M3FNType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ScopedLockableAttr>>(gap::generator<mx::ScopedLockableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPSectionDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPSectionDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCExceptionAttr>>(gap::generator<mx::ObjCExceptionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<std::string_view>>(std::optional<std::string_view>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CallableWhenAttrSpelling>(mx::CallableWhenAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::X86ForceAlignArgPointerAttr>>(std::optional<mx::X86ForceAlignArgPointerAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCExplicitProtocolImplAttr>>(gap::generator<mx::ObjCExplicitProtocolImplAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceUMinOp>(mx::ir::llvm::VPReduceUMinOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CharacterLiteral>>(std::optional<mx::CharacterLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXCatchStmt>(mx::CXXCatchStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ScopedLockableAttr>>(std::optional<mx::ScopedLockableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceUMinOp>>(std::optional<mx::ir::llvm::VPReduceUMinOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCExplicitProtocolImplAttr>>(std::optional<mx::ObjCExplicitProtocolImplAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float8E5M2FNUZType>(mx::ir::builtin::Float8E5M2FNUZType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CallbackAttrSpelling>(mx::CallbackAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXCatchStmt>>(std::optional<mx::CXXCatchStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SYCLKernelAttr>>(gap::generator<mx::SYCLKernelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float8E5M2FNUZType>>(std::optional<mx::ir::builtin::Float8E5M2FNUZType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedDesignatorId>(PackedDesignatorId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXCatchStmt>>(gap::generator<mx::CXXCatchStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CastExpr>>(gap::generator<mx::CastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::vector<std::string>>(std::vector<std::string>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CalledOnceAttrSpelling>(mx::CalledOnceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float8E4M3FNUZType>(mx::ir::builtin::Float8E4M3FNUZType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SYCLSpecialClassAttr>>(gap::generator<mx::SYCLSpecialClassAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float8E4M3FNUZType>>(std::optional<mx::ir::builtin::Float8E4M3FNUZType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCExceptionAttr>>(std::optional<mx::ObjCExceptionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPReduceXorOp>(mx::ir::llvm::VPReduceXorOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBridgeAttr>>(gap::generator<mx::ObjCBridgeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float8E4M3B11FNUZType>(mx::ir::builtin::Float8E4M3B11FNUZType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CapabilityAttrSpelling>(mx::CapabilityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPReduceXorOp>>(std::optional<mx::ir::llvm::VPReduceXorOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SYCLSpecialClassAttr>>(std::optional<mx::SYCLSpecialClassAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WorkGroupSizeHintAttr>(mx::WorkGroupSizeHintAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CastExpr>>(std::optional<mx::CastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyImportModuleAttr>(mx::WebAssemblyImportModuleAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AVRSignalAttrSpelling>(mx::AVRSignalAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WorkGroupSizeHintAttr>>(gap::generator<mx::WorkGroupSizeHintAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedCXXCtorInitializerId>(PackedCXXCtorInitializerId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float8E4M3B11FNUZType>>(std::optional<mx::ir::builtin::Float8E4M3B11FNUZType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CapturedStmtVariableCaptureKind>(mx::CapturedStmtVariableCaptureKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::BFloat16Type>(mx::ir::builtin::BFloat16Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBridgeRelatedAttr>>(gap::generator<mx::ObjCBridgeRelatedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXCatchStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXCatchStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBridgeRelatedAttr>>(std::optional<mx::ObjCBridgeRelatedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::BFloat16Type>>(std::optional<mx::ir::builtin::BFloat16Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CarriesDependencyAttrSpelling>(mx::CarriesDependencyAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPSDivOp>(mx::ir::llvm::VPSDivOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SYCLKernelAttr>>(std::optional<mx::SYCLKernelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float16Type>(mx::ir::builtin::Float16Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AbiTagAttrSpelling>(mx::AbiTagAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPSDivOp>>(std::optional<mx::ir::llvm::VPSDivOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReturnsTwiceAttr>>(gap::generator<mx::ReturnsTwiceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedFragmentId>(PackedFragmentId) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBridgeMutableAttr>>(gap::generator<mx::ObjCBridgeMutableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WorkGroupSizeHintAttr>>(std::optional<mx::WorkGroupSizeHintAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CleanupAttrSpelling>(mx::CleanupAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float16Type>>(std::optional<mx::ir::builtin::Float16Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBridgeMutableAttr>>(std::optional<mx::ObjCBridgeMutableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPScopeDirective>(mx::OMPScopeDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CodeAlignAttrSpelling>(mx::CodeAlignAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelSectionsDirective>(mx::OMPParallelSectionsDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReturnsTwiceAttr>>(std::optional<mx::ReturnsTwiceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPScopeDirective>>(gap::generator<mx::OMPScopeDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReturnsNonNullAttr>>(gap::generator<mx::ReturnsNonNullAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UsingEnumDecl>(mx::UsingEnumDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CodeModelAttrSpelling>(mx::CodeModelAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnnamedGlobalConstantDecl>(mx::UnnamedGlobalConstantDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImplicitCastExpr>>(gap::generator<mx::ImplicitCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingEnumDecl>>(gap::generator<mx::UsingEnumDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ColdAttrSpelling>(mx::ColdAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::FloatTF32Type>(mx::ir::builtin::FloatTF32Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBridgeAttr>>(std::optional<mx::ObjCBridgeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RegexQueryMatch>>(gap::generator<mx::RegexQueryMatch>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImplicitCastExpr>>(std::optional<mx::ImplicitCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RegexQuery>(mx::RegexQuery) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReturnsNonNullAttr>>(std::optional<mx::ReturnsNonNullAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::FloatTF32Type>>(std::optional<mx::ir::builtin::FloatTF32Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CommonAttrSpelling>(mx::CommonAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float32Type>(mx::ir::builtin::Float32Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReturnTypestateAttr>>(gap::generator<mx::ReturnTypestateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPSExtOp>(mx::ir::llvm::VPSExtOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstAttrSpelling>(mx::ConstAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float32Type>>(std::optional<mx::ir::builtin::Float32Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSReturnsRetainedOnZeroAttr>>(gap::generator<mx::OSReturnsRetainedOnZeroAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPSExtOp>>(std::optional<mx::ir::llvm::VPSExtOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReturnTypestateAttr>>(std::optional<mx::ReturnTypestateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPScopeDirective>>(std::optional<mx::OMPScopeDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSReturnsRetainedOnZeroAttr>>(std::optional<mx::OSReturnsRetainedOnZeroAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingEnumDecl>>(std::optional<mx::UsingEnumDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstInitAttrSpelling>(mx::ConstInitAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float64Type>(mx::ir::builtin::Float64Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RetainAttr>>(gap::generator<mx::RetainAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float128Type>(mx::ir::builtin::Float128Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExplicitCastExpr>>(gap::generator<mx::ExplicitCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPScopeDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPScopeDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstructorAttrSpelling>(mx::ConstructorAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float64Type>>(std::optional<mx::ir::builtin::Float64Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSReturnsRetainedOnNonZeroAttr>>(gap::generator<mx::OSReturnsRetainedOnNonZeroAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UsingEnumDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::UsingEnumDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExplicitCastExpr>>(std::optional<mx::ExplicitCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyImportNameAttr>(mx::WebAssemblyImportNameAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAttrConsumedState>(mx::ConsumableAttrConsumedState) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyExportNameAttr>(mx::WebAssemblyExportNameAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RetainAttr>>(std::optional<mx::RetainAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WebAssemblyImportNameAttr>>(gap::generator<mx::WebAssemblyImportNameAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSReturnsRetainedOnNonZeroAttr>>(std::optional<mx::OSReturnsRetainedOnNonZeroAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Float80Type>(mx::ir::builtin::Float80Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RestrictAttr>>(gap::generator<mx::RestrictAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float80Type>>(std::optional<mx::ir::builtin::Float80Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSReturnsRetainedAttr>>(gap::generator<mx::OSReturnsRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPSIToFPOp>(mx::ir::llvm::VPSIToFPOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAttrSpelling>(mx::ConsumableAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPSRemOp>(mx::ir::llvm::VPSRemOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXNamedCastExpr>>(gap::generator<mx::CXXNamedCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SYCLUniqueStableNameExpr>>(gap::generator<mx::SYCLUniqueStableNameExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedFileId>(PackedFileId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCExternallyRetainedAttr>>(gap::generator<mx::ObjCExternallyRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSReturnsRetainedAttr>>(std::optional<mx::OSReturnsRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetParallelGenericLoopDirective>>(std::optional<mx::OMPTargetParallelGenericLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAutoCastAttrSpelling>(mx::ConsumableAutoCastAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ShlOp>>(std::optional<mx::ir::llvm::ShlOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RestrictAttr>>(std::optional<mx::RestrictAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetParallelGenericLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetParallelGenericLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReinitializesAttr>>(gap::generator<mx::ReinitializesAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReturnStmt>>(gap::generator<mx::ReturnStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSConsumesThisAttr>>(gap::generator<mx::OSConsumesThisAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDynamicCastExpr>>(gap::generator<mx::CXXDynamicCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConsumableSetOnReadAttrSpelling>(mx::ConsumableSetOnReadAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SYCLUniqueStableNameExpr>>(std::optional<mx::SYCLUniqueStableNameExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXNamedCastExpr>>(std::optional<mx::CXXNamedCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCExternallyRetainedAttr>>(std::optional<mx::ObjCExternallyRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RequiresCapabilityAttr>>(gap::generator<mx::RequiresCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::StoreOp>(mx::ir::llvm::StoreOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConvergentAttrSpelling>(mx::ConvergentAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCImplementationDecl>>(std::optional<mx::ObjCImplementationDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSReturnsNotRetainedAttr>>(gap::generator<mx::OSReturnsNotRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ShuffleVectorOp>(mx::ir::llvm::ShuffleVectorOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RequiresCapabilityAttr>>(std::optional<mx::RequiresCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::SYCLUniqueStableNameExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::SYCLUniqueStableNameExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSReturnsNotRetainedAttr>>(std::optional<mx::OSReturnsNotRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ShuffleVectorOp>>(std::optional<mx::ir::llvm::ShuffleVectorOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDynamicCastExpr>>(gap::generator<mx::CXXDynamicCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReturnStmt>>(std::optional<mx::ReturnStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroDisableLifetimeBoundAttrSpelling>(mx::CoroDisableLifetimeBoundAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCImplementationDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCImplementationDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReqdWorkGroupSizeAttr>>(gap::generator<mx::ReqdWorkGroupSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDynamicCastExpr>>(std::optional<mx::CXXDynamicCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroLifetimeBoundAttrSpelling>(mx::CoroLifetimeBoundAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ReturnStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ReturnStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSConsumesThisAttr>>(std::optional<mx::OSConsumesThisAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXDynamicCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXDynamicCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDynamicCastExpr>>(std::optional<mx::CXXDynamicCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SubOp>(mx::ir::llvm::SubOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReqdWorkGroupSizeAttr>>(std::optional<mx::ReqdWorkGroupSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCExplicitProtocolImplAttr>>(gap::generator<mx::ObjCExplicitProtocolImplAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroOnlyDestroyWhenCompleteAttrSpelling>(mx::CoroOnlyDestroyWhenCompleteAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::StoreOp>>(std::optional<mx::ir::llvm::StoreOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReleaseCapabilityAttr>>(gap::generator<mx::ReleaseCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetParallelForSimdDirective>>(gap::generator<mx::OMPTargetParallelForSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareVariantAttr>>(gap::generator<mx::OMPDeclareVariantAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SubOp>>(std::optional<mx::ir::llvm::SubOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroReturnTypeAttrSpelling>(mx::CoroReturnTypeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCExplicitProtocolImplAttr>>(std::optional<mx::ObjCExplicitProtocolImplAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXConstCastExpr>>(gap::generator<mx::CXXConstCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetParallelForSimdDirective>>(std::optional<mx::OMPTargetParallelForSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPThreadPrivateDeclAttr>>(gap::generator<mx::OMPThreadPrivateDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PseudoObjectExpr>(mx::PseudoObjectExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::variant<mx::MacroSubstitution, mx::MacroVAOpt>>(std::variant<mx::MacroSubstitution, mx::MacroVAOpt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RequiresExpr>>(gap::generator<mx::RequiresExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReleaseCapabilityAttr>>(std::optional<mx::ReleaseCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::TruncOp>(mx::ir::llvm::TruncOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroWrapperAttrSpelling>(mx::CoroWrapperAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetParallelForSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetParallelForSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPThreadPrivateDeclAttr>>(std::optional<mx::OMPThreadPrivateDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::SwitchOp>(mx::ir::llvm::SwitchOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareVariantAttr>>(std::optional<mx::OMPDeclareVariantAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::SwitchOp>>(std::optional<mx::ir::llvm::SwitchOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXConstCastExpr>>(std::optional<mx::CXXConstCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCForCollectionStmt>>(gap::generator<mx::ObjCForCollectionStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CountedByAttrSpelling>(mx::CountedByAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXConstCastExpr>>(gap::generator<mx::CXXConstCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedFragmentId>(PackedFragmentId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCExceptionAttr>(mx::ObjCExceptionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DLLExportAttrSpelling>(mx::DLLExportAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UDivOp>(mx::ir::llvm::UDivOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReinitializesAttr>>(std::optional<mx::ReinitializesAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCExceptionAttr>>(gap::generator<mx::ObjCExceptionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPAllocateDeclAttr>>(gap::generator<mx::OMPAllocateDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RequiresExpr>>(std::optional<mx::RequiresExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXStaticCastExpr>>(gap::generator<mx::CXXStaticCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::TruncOp>>(std::optional<mx::ir::llvm::TruncOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RegCallAttr>>(gap::generator<mx::RegCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::RequiresExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::RequiresExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DLLImportAttrSpelling>(mx::DLLImportAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCCategoryDecl>(mx::ObjCCategoryDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareTargetDeclAttr>>(gap::generator<mx::OMPDeclareTargetDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCForCollectionStmt>>(std::optional<mx::ObjCForCollectionStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXAddrspaceCastExpr>>(gap::generator<mx::CXXAddrspaceCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCCategoryDecl>>(std::optional<mx::ObjCCategoryDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareTargetDeclAttr>>(std::optional<mx::OMPDeclareTargetDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXConstCastExpr>>(std::optional<mx::CXXConstCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclFriendObjectKind>(mx::DeclFriendObjectKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCCategoryDecl>>(gap::generator<mx::ObjCCategoryDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedCompilationId>(PackedCompilationId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCForCollectionStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCForCollectionStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RegCallAttr>>(std::optional<mx::RegCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCExceptionAttr>>(std::optional<mx::ObjCExceptionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXAddrspaceCastExpr>>(std::optional<mx::CXXAddrspaceCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXConstCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXConstCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RandomizeLayoutAttr>>(gap::generator<mx::RandomizeLayoutAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UDivOp>>(std::optional<mx::ir::llvm::UDivOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclIdentifierNamespace>(mx::DeclIdentifierNamespace) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetParallelForDirective>>(gap::generator<mx::OMPTargetParallelForDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCaptureNoInitAttr>>(gap::generator<mx::OMPCaptureNoInitAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::URemOp>(mx::ir::llvm::URemOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclModuleOwnershipKind>(mx::DeclModuleOwnershipKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UIToFPOp>(mx::ir::llvm::UIToFPOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReadOnlyPlacementAttr>>(gap::generator<mx::ReadOnlyPlacementAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCCategoryDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCCategoryDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReadOnlyPlacementAttr>>(std::optional<mx::ReadOnlyPlacementAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UIToFPOp>>(std::optional<mx::ir::llvm::UIToFPOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCaptureNoInitAttr>>(std::optional<mx::OMPCaptureNoInitAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeRelatedAttr>(mx::ObjCBridgeRelatedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclObjCDeclQualifier>(mx::DeclObjCDeclQualifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBridgeRelatedAttr>>(gap::generator<mx::ObjCBridgeRelatedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPAllocateDeclAttr>>(std::optional<mx::OMPAllocateDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UndefOp>(mx::ir::llvm::UndefOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXStaticCastExpr>>(std::optional<mx::CXXStaticCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RequiresExprBodyDecl>(mx::RequiresExprBodyDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeprecatedAttrSpelling>(mx::DeprecatedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetParallelForDirective>>(std::optional<mx::OMPTargetParallelForDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LockReturnedAttr>>(gap::generator<mx::LockReturnedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::URemOp>>(std::optional<mx::ir::llvm::URemOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<PackedDeclId>(PackedDeclId) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RequiresExprBodyDecl>>(gap::generator<mx::RequiresExprBodyDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RandomizeLayoutAttr>>(std::optional<mx::RandomizeLayoutAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTargetParallelForDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTargetParallelForDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CStyleCastExpr>>(gap::generator<mx::CStyleCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBridgeRelatedAttr>>(std::optional<mx::ObjCBridgeRelatedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DestructorAttrSpelling>(mx::DestructorAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXAddrspaceCastExpr>(mx::CXXAddrspaceCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RISCVInterruptAttr>>(gap::generator<mx::RISCVInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXReinterpretCastExpr>(mx::CXXReinterpretCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NotTailCalledAttr>>(gap::generator<mx::NotTailCalledAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXAddrspaceCastExpr>>(gap::generator<mx::CXXAddrspaceCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXReinterpretCastExpr>>(gap::generator<mx::CXXReinterpretCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCAutoreleasePoolStmt>(mx::ObjCAutoreleasePoolStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DiagnoseAsBuiltinAttrSpelling>(mx::DiagnoseAsBuiltinAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtThrowStmt>(mx::ObjCAtThrowStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NotTailCalledAttr>>(std::optional<mx::NotTailCalledAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAutoreleasePoolStmt>>(gap::generator<mx::ObjCAutoreleasePoolStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXReinterpretCastExpr>>(std::optional<mx::CXXReinterpretCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RequiresExprBodyDecl>>(std::optional<mx::RequiresExprBodyDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DiagnoseIfAttrDiagnosticType>(mx::DiagnoseIfAttrDiagnosticType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UndefOp>>(std::optional<mx::ir::llvm::UndefOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RISCVInterruptAttr>>(std::optional<mx::RISCVInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::RequiresExprBodyDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::RequiresExprBodyDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoUwtableAttr>>(gap::generator<mx::NoUwtableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeMutableAttr>(mx::ObjCBridgeMutableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PureAttr>>(gap::generator<mx::PureAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::XOrOp>(mx::ir::llvm::XOrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DisableSanitizerInstrumentationAttrSpelling>(mx::DisableSanitizerInstrumentationAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXAddrspaceCastExpr>>(std::optional<mx::CXXAddrspaceCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoUwtableAttr>>(std::optional<mx::NoUwtableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBridgeMutableAttr>>(gap::generator<mx::ObjCBridgeMutableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXFunctionalCastExpr>>(gap::generator<mx::CXXFunctionalCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::UnreachableOp>(mx::ir::llvm::UnreachableOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DisableTailCallsAttrSpelling>(mx::DisableTailCallsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCCategoryImplDecl>(mx::ObjCCategoryImplDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PureAttr>>(std::optional<mx::PureAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAutoreleasePoolStmt>>(std::optional<mx::ObjCAutoreleasePoolStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoUniqueAddressAttr>>(gap::generator<mx::NoUniqueAddressAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXAddrspaceCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXAddrspaceCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PtGuardedVarAttr>>(gap::generator<mx::PtGuardedVarAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCCategoryImplDecl>>(gap::generator<mx::ObjCCategoryImplDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXFunctionalCastExpr>>(std::optional<mx::CXXFunctionalCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::UnreachableOp>>(std::optional<mx::ir::llvm::UnreachableOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnforceTCBAttrSpelling>(mx::EnforceTCBAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCAutoreleasePoolStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCAutoreleasePoolStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoUniqueAddressAttr>>(std::optional<mx::NoUniqueAddressAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ZExtOp>(mx::ir::llvm::ZExtOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnforceTCBLeafAttrSpelling>(mx::EnforceTCBLeafAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::XOrOp>>(std::optional<mx::ir::llvm::XOrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PtGuardedVarAttr>>(std::optional<mx::PtGuardedVarAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBridgeMutableAttr>>(std::optional<mx::ObjCBridgeMutableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoThrowAttr>>(gap::generator<mx::NoThrowAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPSimdDirective>(mx::OMPSimdDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnumExtensibilityAttrKind>(mx::EnumExtensibilityAttrKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMasterTaskLoopDirective>(mx::OMPParallelMasterTaskLoopDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::File>(mx::File) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPSimdDirective>>(gap::generator<mx::OMPSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnumExtensibilityAttrSpelling>(mx::EnumExtensibilityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCCategoryImplDecl>>(std::optional<mx::ObjCCategoryImplDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PtGuardedByAttr>>(std::optional<mx::PtGuardedByAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCCategoryImplDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCCategoryImplDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoThrowAttr>>(std::optional<mx::NoThrowAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ZeroOp>(mx::ir::llvm::ZeroOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CStyleCastExpr>>(std::optional<mx::CStyleCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ZExtOp>>(std::optional<mx::ir::llvm::ZExtOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PreferredTypeAttr>>(gap::generator<mx::PreferredTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPSimdDirective>>(std::optional<mx::OMPSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ErrorAttrSpelling>(mx::ErrorAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeAttr>(mx::ObjCBridgeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PreserveMostAttr>>(gap::generator<mx::PreserveMostAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedOnNonZeroAttr>(mx::OSReturnsRetainedOnNonZeroAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoSplitStackAttr>>(gap::generator<mx::NoSplitStackAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBridgeAttr>>(gap::generator<mx::ObjCBridgeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinBitCastExpr>>(gap::generator<mx::BuiltinBitCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmOutAttr>>(gap::generator<mx::ArmOutAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AbsOp>(mx::ir::llvm::AbsOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReleaseCapabilityAttr>(mx::ReleaseCapabilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXStaticCastExpr>(mx::CXXStaticCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CStyleCastExpr>(mx::CStyleCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXFunctionalCastExpr>(mx::CXXFunctionalCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TopLevelStmtDecl>>(gap::generator<mx::TopLevelStmtDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ZeroOp>>(std::optional<mx::ir::llvm::ZeroOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::File>>(std::optional<mx::File>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXStaticCastExpr>>(gap::generator<mx::CXXStaticCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RequiresExpr>>(std::optional<mx::RequiresExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RecoveryExpr>(mx::RecoveryExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TopLevelStmtDecl>>(std::optional<mx::TopLevelStmtDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PredefinedExpr>(mx::PredefinedExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReinitializesAttr>(mx::ReinitializesAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RecoveryExpr>>(gap::generator<mx::RecoveryExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BuiltinBitCastExpr>(mx::BuiltinBitCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtTryStmt>(mx::ObjCAtTryStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmOutAttr>>(std::optional<mx::ArmOutAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtSynchronizedStmt>(mx::ObjCAtSynchronizedStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RegCallAttr>(mx::RegCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtTryStmt>>(gap::generator<mx::ObjCAtTryStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgedCastExpr>(mx::ObjCBridgedCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBridgeAttr>>(std::optional<mx::ObjCBridgeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RecoveryExpr>>(gap::generator<mx::RecoveryExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AbsOp>>(std::optional<mx::ir::llvm::AbsOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmInOutAttr>>(gap::generator<mx::ArmInOutAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXStaticCastExpr>>(std::optional<mx::CXXStaticCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmMveStrictPolymorphismAttr>>(gap::generator<mx::ArmMveStrictPolymorphismAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RecoveryExpr>>(std::optional<mx::RecoveryExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReadOnlyPlacementAttr>(mx::ReadOnlyPlacementAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtTryStmt>>(std::optional<mx::ObjCAtTryStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CallExpr>(mx::CallExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXStaticCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXStaticCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StaticAssertDecl>>(std::optional<mx::StaticAssertDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::RecoveryExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::RecoveryExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmMveStrictPolymorphismAttr>>(std::optional<mx::ArmMveStrictPolymorphismAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AnnotationOp>(mx::ir::llvm::AnnotationOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RequiresExprBodyDecl>>(gap::generator<mx::RequiresExprBodyDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCAtTryStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCAtTryStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RandomizeLayoutAttr>(mx::RandomizeLayoutAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AnnotationOp>>(std::optional<mx::ir::llvm::AnnotationOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXOperatorCallExpr>(mx::CXXOperatorCallExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedOnZeroAttr>(mx::OSReturnsRetainedOnZeroAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RequiresExprBodyDecl>>(std::optional<mx::RequiresExprBodyDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedAttr>(mx::OSReturnsRetainedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLBufferDecl>>(gap::generator<mx::HLSLBufferDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSReturnsRetainedOnZeroAttr>>(gap::generator<mx::OSReturnsRetainedOnZeroAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmInOutAttr>>(std::optional<mx::ArmInOutAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AssumeOp>(mx::ir::llvm::AssumeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmInAttr>>(gap::generator<mx::ArmInAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMasterTaskLoopSimdDirective>(mx::OMPParallelMasterTaskLoopSimdDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RISCVInterruptAttr>(mx::RISCVInterruptAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::BitReverseOp>(mx::ir::llvm::BitReverseOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXMemberCallExpr>(mx::CXXMemberCallExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMaskedTaskLoopSimdDirective>(mx::OMPParallelMaskedTaskLoopSimdDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RecoveryExpr>>(std::optional<mx::RecoveryExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMasterTaskLoopSimdDirective>>(gap::generator<mx::OMPParallelMasterTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaCommentDecl>>(gap::generator<mx::PragmaCommentDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFUnknownTransferAttr>>(gap::generator<mx::CFUnknownTransferAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Macro>>(std::optional<mx::Macro>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExcludeFromExplicitInstantiationAttr>>(std::optional<mx::ExcludeFromExplicitInstantiationAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaDetectMismatchDecl>>(gap::generator<mx::PragmaDetectMismatchDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCCompatibleAliasDecl>>(gap::generator<mx::ObjCCompatibleAliasDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PureAttr>(mx::PureAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSPropertySubscriptExpr>>(std::optional<mx::MSPropertySubscriptExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDAKernelCallExpr>(mx::CUDAKernelCallExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeNonNullAttr>>(gap::generator<mx::TypeNonNullAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmInAttr>>(std::optional<mx::ArmInAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSInheritanceAttr>>(std::optional<mx::MSInheritanceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaDetectMismatchDecl>>(std::optional<mx::PragmaDetectMismatchDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFUnknownTransferAttr>>(std::optional<mx::CFUnknownTransferAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnnotateTypeAttr>>(gap::generator<mx::AnnotateTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::MSPropertySubscriptExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::MSPropertySubscriptExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PtGuardedVarAttr>(mx::PtGuardedVarAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ErrorAttr>>(gap::generator<mx::ErrorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UserDefinedLiteral>(mx::UserDefinedLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCCompatibleAliasDecl>>(std::optional<mx::ObjCCompatibleAliasDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PseudoObjectExpr>>(gap::generator<mx::PseudoObjectExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeNonNullAttr>>(std::optional<mx::TypeNonNullAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnnotateTypeAttr>>(std::optional<mx::AnnotateTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPScanDirective>>(gap::generator<mx::OMPScanDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PtGuardedByAttr>(mx::PtGuardedByAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCCompatibleAliasDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCCompatibleAliasDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXUuidofExpr>(mx::CXXUuidofExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFReturnsRetainedAttr>>(gap::generator<mx::CFReturnsRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AddressSpaceAttr>>(gap::generator<mx::AddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSConstexprAttr>>(gap::generator<mx::MSConstexprAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PseudoObjectExpr>>(std::optional<mx::PseudoObjectExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ErrorAttr>>(std::optional<mx::ErrorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateParameterList>>(gap::generator<mx::TemplateParameterList>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPScanDirective>>(std::optional<mx::OMPScanDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaCommentDecl>>(std::optional<mx::PragmaCommentDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPScanDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPScanDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PreserveMostAttr>(mx::PreserveMostAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ThreadAttr>>(gap::generator<mx::ThreadAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXUnresolvedConstructExpr>(mx::CXXUnresolvedConstructExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFReturnsRetainedAttr>>(std::optional<mx::CFReturnsRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AddressSpaceAttr>>(std::optional<mx::AddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSConstexprAttr>>(std::optional<mx::MSConstexprAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXBaseSpecifier>>(gap::generator<mx::CXXBaseSpecifier>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IntegerLiteral>(mx::IntegerLiteral) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UPtrAttr>>(gap::generator<mx::UPtrAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSPropertyRefExpr>>(gap::generator<mx::MSPropertyRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PreserveAllAttr>(mx::PreserveAllAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnumExtensibilityAttr>>(gap::generator<mx::EnumExtensibilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXTypeidExpr>(mx::CXXTypeidExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ThreadAttr>>(std::optional<mx::ThreadAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLBufferDecl>>(std::optional<mx::HLSLBufferDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NamespaceAliasDecl>(mx::NamespaceAliasDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WebAssemblyFuncrefAttr>>(gap::generator<mx::WebAssemblyFuncrefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExternCContextDecl>(mx::ExternCContextDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PredefinedExpr>>(gap::generator<mx::PredefinedExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NamespaceAliasDecl>>(gap::generator<mx::NamespaceAliasDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PreferredTypeAttr>(mx::PreferredTypeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFReturnsNotRetainedAttr>>(gap::generator<mx::CFReturnsNotRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXThrowExpr>(mx::CXXThrowExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSAllocatorAttr>>(gap::generator<mx::MSAllocatorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WebAssemblyFuncrefAttr>>(std::optional<mx::WebAssemblyFuncrefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSPropertyRefExpr>>(std::optional<mx::MSPropertyRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PredefinedExpr>>(std::optional<mx::PredefinedExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnumExtensibilityAttr>>(std::optional<mx::EnumExtensibilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingEnumDecl>>(gap::generator<mx::UsingEnumDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::MSPropertyRefExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::MSPropertyRefExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PreferredNameAttr>(mx::PreferredNameAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftVersionedRemovalAttr>(mx::SwiftVersionedRemovalAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXNewExpr>(mx::CXXNewExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftVersionedRemovalAttr>>(gap::generator<mx::SwiftVersionedRemovalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UPtrAttr>>(std::optional<mx::UPtrAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NamespaceAliasDecl>>(std::optional<mx::NamespaceAliasDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangTextSectionAttr>(mx::PragmaClangTextSectionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFReturnsNotRetainedAttr>>(std::optional<mx::CFReturnsNotRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXThisExpr>(mx::CXXThisExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSAllocatorAttr>>(std::optional<mx::MSAllocatorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParenListExpr>>(gap::generator<mx::ParenListExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelSectionsDirective>>(gap::generator<mx::OMPParallelSectionsDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingEnumDecl>>(std::optional<mx::UsingEnumDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::NamespaceAliasDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::NamespaceAliasDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeNullableAttr>>(gap::generator<mx::TypeNullableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnforceTCBLeafAttr>(mx::EnforceTCBLeafAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangRodataSectionAttr>(mx::PragmaClangRodataSectionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnforceTCBLeafAttr>>(gap::generator<mx::EnforceTCBLeafAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXStdInitializerListExpr>(mx::CXXStdInitializerListExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftVersionedRemovalAttr>>(std::optional<mx::SwiftVersionedRemovalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeNullableResultAttr>>(gap::generator<mx::TypeNullableResultAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelSectionsDirective>>(std::optional<mx::OMPParallelSectionsDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParenListExpr>>(std::optional<mx::ParenListExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFICanonicalJumpTableAttr>(mx::CFICanonicalJumpTableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnumDecl>>(gap::generator<mx::EnumDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSABIAttr>(mx::MSABIAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::vector<std::string>>(std::vector<std::string>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelSectionsDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelSectionsDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeNullableResultAttr>>(std::optional<mx::TypeNullableResultAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFICanonicalJumpTableAttr>>(gap::generator<mx::CFICanonicalJumpTableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangRelroSectionAttr>(mx::PragmaClangRelroSectionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSABIAttr>>(gap::generator<mx::MSABIAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXScalarValueInitExpr>(mx::CXXScalarValueInitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnforceTCBLeafAttr>>(std::optional<mx::EnforceTCBLeafAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParenExpr>>(gap::generator<mx::ParenExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSPropertyDecl>(mx::MSPropertyDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnumDecl>>(std::optional<mx::EnumDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSPropertyDecl>>(gap::generator<mx::MSPropertyDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangDataSectionAttr>(mx::PragmaClangDataSectionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftVersionedAdditionAttr>(mx::SwiftVersionedAdditionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXRewrittenBinaryOperator>(mx::CXXRewrittenBinaryOperator) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftVersionedAdditionAttr>>(gap::generator<mx::SwiftVersionedAdditionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeNullableAttr>>(std::optional<mx::TypeNullableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFICanonicalJumpTableAttr>>(std::optional<mx::CFICanonicalJumpTableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeNonNullAttr>>(gap::generator<mx::TypeNonNullAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSABIAttr>>(std::optional<mx::MSABIAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParenExpr>>(std::optional<mx::ParenExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnforceTCBAttr>(mx::EnforceTCBAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnumConstantDecl>>(gap::generator<mx::EnumConstantDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSPropertyDecl>>(std::optional<mx::MSPropertyDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangBSSSectionAttr>(mx::PragmaClangBSSSectionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LinkageSpecDecl>>(gap::generator<mx::LinkageSpecDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXPseudoDestructorExpr>(mx::CXXPseudoDestructorExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnforceTCBAttr>>(gap::generator<mx::EnforceTCBAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeNullUnspecifiedAttr>>(gap::generator<mx::TypeNullUnspecifiedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftVersionedAdditionAttr>>(std::optional<mx::SwiftVersionedAdditionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeNullUnspecifiedAttr>>(std::optional<mx::TypeNullUnspecifiedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::MSPropertyDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::MSPropertyDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PointerAttr>(mx::PointerAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFGuardAttr>(mx::CFGuardAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXParenListInitExpr>(mx::CXXParenListInitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MIGServerRoutineAttr>(mx::MIGServerRoutineAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PackExpansionExpr>>(gap::generator<mx::PackExpansionExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFGuardAttr>>(gap::generator<mx::CFGuardAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnumConstantDecl>>(std::optional<mx::EnumConstantDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MIGServerRoutineAttr>>(gap::generator<mx::MIGServerRoutineAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PcsAttr>(mx::PcsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMasterDirective>(mx::OMPParallelMasterDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXNullPtrLiteralExpr>(mx::CXXNullPtrLiteralExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelDirective>(mx::OMPParallelDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeNonNullAttr>>(std::optional<mx::TypeNonNullAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMasterDirective>>(gap::generator<mx::OMPParallelMasterDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PackExpansionExpr>>(std::optional<mx::PackExpansionExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LinkageSpecDecl>>(std::optional<mx::LinkageSpecDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ThreadAttr>>(gap::generator<mx::ThreadAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnforceTCBAttr>>(std::optional<mx::EnforceTCBAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PatchableFunctionEntryAttr>(mx::PatchableFunctionEntryAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::LinkageSpecDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::LinkageSpecDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXNoexceptExpr>(mx::CXXNoexceptExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftObjCMembersAttr>(mx::SwiftObjCMembersAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OffsetOfExpr>>(gap::generator<mx::OffsetOfExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFGuardAttr>>(std::optional<mx::CFGuardAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ThreadAttr>>(std::optional<mx::ThreadAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MIGServerRoutineAttr>>(std::optional<mx::MIGServerRoutineAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingDecl>>(gap::generator<mx::UsingDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLUnrollHintAttr>(mx::OpenCLUnrollHintAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PascalAttr>(mx::PascalAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftObjCMembersAttr>>(gap::generator<mx::SwiftObjCMembersAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXConstructExpr>(mx::CXXConstructExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMasterDirective>>(std::optional<mx::OMPParallelMasterDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedMemberExpr>>(gap::generator<mx::UnresolvedMemberExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelMasterDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelMasterDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingDecl>>(std::optional<mx::UsingDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnableIfAttr>(mx::EnableIfAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParamTypestateAttr>(mx::ParamTypestateAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DisableTailCallsAttr>(mx::DisableTailCallsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXInheritedCtorInitExpr>(mx::CXXInheritedCtorInitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnableIfAttr>>(gap::generator<mx::EnableIfAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedMemberExpr>>(std::optional<mx::UnresolvedMemberExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftObjCMembersAttr>>(std::optional<mx::SwiftObjCMembersAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftVersionedRemovalAttr>>(gap::generator<mx::SwiftVersionedRemovalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::M68kRTDAttr>(mx::M68kRTDAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftVersionedRemovalAttr>>(std::optional<mx::SwiftVersionedRemovalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LocksExcludedAttr>(mx::LocksExcludedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PackedAttr>(mx::PackedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::M68kRTDAttr>>(gap::generator<mx::M68kRTDAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ValueStmt>>(std::optional<mx::ValueStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFAuditedTransferAttr>(mx::CFAuditedTransferAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXFoldExpr>(mx::CXXFoldExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::C11NoReturnAttr>(mx::C11NoReturnAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OwnershipAttr>(mx::OwnershipAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFAuditedTransferAttr>>(gap::generator<mx::CFAuditedTransferAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXDependentScopeMemberExpr>(mx::CXXDependentScopeMemberExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ImaginaryLiteral>(mx::ImaginaryLiteral) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OffsetOfExpr>>(std::optional<mx::OffsetOfExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LambdaExpr>>(gap::generator<mx::LambdaExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedUsingValueDecl>>(gap::generator<mx::UnresolvedUsingValueDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnableIfAttr>>(std::optional<mx::EnableIfAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StmtAttr>>(gap::generator<mx::StmtAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StmtAttr>(mx::StmtAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedUsingValueDecl>>(std::optional<mx::UnresolvedUsingValueDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::M68kRTDAttr>>(std::optional<mx::M68kRTDAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftVersionedAdditionAttr>>(gap::generator<mx::SwiftVersionedAdditionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MustTailAttr>(mx::MustTailAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OwnerAttr>(mx::OwnerAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StmtAttr>>(gap::generator<mx::StmtAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXDeleteExpr>(mx::CXXDeleteExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFAuditedTransferAttr>>(std::optional<mx::CFAuditedTransferAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftVersionedAdditionAttr>>(std::optional<mx::SwiftVersionedAdditionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ImportDecl>(mx::ImportDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCStringLiteral>>(gap::generator<mx::ObjCStringLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LambdaExpr>>(std::optional<mx::LambdaExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftObjCMembersAttr>>(gap::generator<mx::SwiftObjCMembersAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FriendTemplateDecl>(mx::FriendTemplateDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCapturedExprDecl>>(gap::generator<mx::OMPCapturedExprDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImportDecl>>(gap::generator<mx::ImportDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OverrideAttr>(mx::OverrideAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::LambdaExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::LambdaExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXDefaultInitExpr>(mx::CXXDefaultInitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMaskedDirective>(mx::OMPParallelMaskedDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCSubscriptRefExpr>>(gap::generator<mx::ObjCSubscriptRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPOrderedDirective>(mx::OMPOrderedDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnnamedGlobalConstantDecl>>(gap::generator<mx::UnnamedGlobalConstantDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMaskedDirective>>(gap::generator<mx::OMPParallelMaskedDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OptimizeNoneAttr>(mx::OptimizeNoneAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StmtAttr>>(std::optional<mx::StmtAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftObjCMembersAttr>>(std::optional<mx::SwiftObjCMembersAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EmptyBasesAttr>(mx::EmptyBasesAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXDefaultArgExpr>(mx::CXXDefaultArgExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DisableSanitizerInstrumentationAttr>(mx::DisableSanitizerInstrumentationAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCSubscriptRefExpr>>(std::optional<mx::ObjCSubscriptRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EmptyBasesAttr>>(gap::generator<mx::EmptyBasesAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnnamedGlobalConstantDecl>>(std::optional<mx::UnnamedGlobalConstantDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImportDecl>>(std::optional<mx::ImportDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLKernelAttr>(mx::OpenCLKernelAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::M68kInterruptAttr>(mx::M68kInterruptAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Expr>>(std::optional<mx::Expr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LockReturnedAttr>(mx::LockReturnedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXTemporaryObjectExpr>(mx::CXXTemporaryObjectExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::M68kInterruptAttr>>(gap::generator<mx::M68kInterruptAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StmtAttr>>(std::optional<mx::StmtAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CDeclAttr>(mx::CDeclAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateParamObjectDecl>>(gap::generator<mx::TemplateParamObjectDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BuiltinAttr>(mx::BuiltinAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MustTailAttr>>(gap::generator<mx::MustTailAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CDeclAttr>>(gap::generator<mx::CDeclAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLIntelReqdSubGroupSizeAttr>(mx::OpenCLIntelReqdSubGroupSizeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ImportDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ImportDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXBoolLiteralExpr>(mx::CXXBoolLiteralExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMaskedDirective>>(std::optional<mx::OMPParallelMaskedDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateParamObjectDecl>>(std::optional<mx::TemplateParamObjectDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelMaskedDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelMaskedDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLUnrollHintAttr>>(gap::generator<mx::OpenCLUnrollHintAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EmptyBasesAttr>>(std::optional<mx::EmptyBasesAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCSubclassingRestrictedAttr>(mx::ObjCSubclassingRestrictedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDefaultArgExpr>>(gap::generator<mx::CXXDefaultArgExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXBindTemporaryExpr>(mx::CXXBindTemporaryExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MatrixType>>(std::optional<mx::MatrixType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLUnrollHintAttr>>(std::optional<mx::OpenCLUnrollHintAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXBaseSpecifier>>(std::optional<mx::CXXBaseSpecifier>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareReductionDecl>>(gap::generator<mx::OMPDeclareReductionDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ReturnOp>>(std::optional<mx::ir::hl::ReturnOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCStringLiteral>>(std::optional<mx::ObjCStringLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDefaultArgExpr>>(std::optional<mx::CXXDefaultArgExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRootClassAttr>(mx::ObjCRootClassAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::SizeOfExprOp>(mx::ir::hl::SizeOfExprOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BlockExpr>(mx::BlockExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXDefaultArgExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXDefaultArgExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareReductionDecl>>(std::optional<mx::OMPDeclareReductionDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::SizeOfExprOp>>(std::optional<mx::ir::hl::SizeOfExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MustTailAttr>>(std::optional<mx::MustTailAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentSizedMatrixType>>(gap::generator<mx::DependentSizedMatrixType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCReturnsInnerPointerAttr>(mx::ObjCReturnsInnerPointerAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnumDecl>(mx::EnumDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LikelyAttr>>(gap::generator<mx::LikelyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXRecordDecl>(mx::CXXRecordDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BlockDecl>(mx::BlockDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnumDecl>>(gap::generator<mx::EnumDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCSelectorExpr>>(gap::generator<mx::ObjCSelectorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Designator>(mx::Designator) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRequiresSuperAttr>(mx::ObjCRequiresSuperAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::SizeOfTypeOp>(mx::ir::hl::SizeOfTypeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BinaryOperator>(mx::BinaryOperator) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentSizedMatrixType>>(std::optional<mx::DependentSizedMatrixType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LikelyAttr>>(std::optional<mx::LikelyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXRecordDecl>>(std::optional<mx::CXXRecordDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCSelectorExpr>>(std::optional<mx::ObjCSelectorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::SizeOfTypeOp>>(std::optional<mx::ir::hl::SizeOfTypeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCapturedExprDecl>>(std::optional<mx::OMPCapturedExprDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedDesignatorId>(PackedDesignatorId) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FallThroughAttr>>(gap::generator<mx::FallThroughAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Designator>>(gap::generator<mx::Designator>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRequiresPropertyDefsAttr>(mx::ObjCRequiresPropertyDefsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnumDecl>>(std::optional<mx::EnumDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CompoundAssignOperator>(mx::CompoundAssignOperator) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::StaticAssertDeclOp>(mx::ir::hl::StaticAssertDeclOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCProtocolExpr>>(gap::generator<mx::ObjCProtocolExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::EnumDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::EnumDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DecompositionDecl>>(gap::generator<mx::DecompositionDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::StaticAssertDeclOp>>(std::optional<mx::ir::hl::StaticAssertDeclOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FallThroughAttr>>(std::optional<mx::FallThroughAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstantMatrixType>>(gap::generator<mx::ConstantMatrixType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCPreciseLifetimeAttr>(mx::ObjCPreciseLifetimeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Designator>>(std::optional<mx::Designator>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AtomicExpr>(mx::AtomicExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::StmtExprOp>(mx::ir::hl::StmtExprOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCProtocolExpr>>(std::optional<mx::ObjCProtocolExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXTemporaryObjectExpr>(mx::CXXTemporaryObjectExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DecompositionDecl>>(std::optional<mx::DecompositionDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXTemporaryObjectExpr>>(gap::generator<mx::CXXTemporaryObjectExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCOwnershipAttr>(mx::ObjCOwnershipAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::StmtExprOp>>(std::optional<mx::ir::hl::StmtExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AsTypeExpr>(mx::AsTypeExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstantMatrixType>>(std::optional<mx::ConstantMatrixType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CodeAlignAttr>>(std::optional<mx::CodeAlignAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::StructDeclOp>(mx::ir::hl::StructDeclOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCNSObjectAttr>(mx::ObjCNSObjectAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::StructDeclOp>>(std::optional<mx::ir::hl::StructDeclOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArrayTypeTraitExpr>(mx::ArrayTypeTraitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXTemporaryObjectExpr>>(std::optional<mx::CXXTemporaryObjectExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCMessageExpr>>(gap::generator<mx::ObjCMessageExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXTemporaryObjectExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXTemporaryObjectExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BindingDecl>>(gap::generator<mx::BindingDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroQualifiedType>(mx::MacroQualifiedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnlikelyAttr>>(gap::generator<mx::UnlikelyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXCtorInitializer>(mx::CXXCtorInitializer) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodFamilyAttr>(mx::ObjCMethodFamilyAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroQualifiedType>>(gap::generator<mx::MacroQualifiedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArraySubscriptExpr>(mx::ArraySubscriptExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EnumConstantDecl>(mx::EnumConstantDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnlikelyAttr>>(std::optional<mx::UnlikelyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::SubFOp>(mx::ir::hl::SubFOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCMessageExpr>>(std::optional<mx::ObjCMessageExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnumConstantDecl>>(std::optional<mx::EnumConstantDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BindingDecl>>(std::optional<mx::BindingDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::SubFAssignOp>(mx::ir::hl::SubFAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OverloadableAttr>>(gap::generator<mx::OverloadableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnumConstantDecl>>(gap::generator<mx::EnumConstantDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCIndependentClassAttr>(mx::ObjCIndependentClassAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::SubFAssignOp>>(std::optional<mx::ir::hl::SubFAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArrayInitLoopExpr>(mx::ArrayInitLoopExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedCXXCtorInitializerId>(PackedCXXCtorInitializerId) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RenderScriptKernelAttr>>(gap::generator<mx::RenderScriptKernelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXCtorInitializer>>(gap::generator<mx::CXXCtorInitializer>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RenderScriptKernelAttr>>(std::optional<mx::RenderScriptKernelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroQualifiedType>>(std::optional<mx::MacroQualifiedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCExternallyRetainedAttr>(mx::ObjCExternallyRetainedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::SubFOp>>(std::optional<mx::ir::hl::SubFOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArrayInitIndexExpr>(mx::ArrayInitIndexExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXCtorInitializer>>(std::optional<mx::CXXCtorInitializer>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIvarRefExpr>>(gap::generator<mx::ObjCIvarRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::EnumConstantDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::EnumConstantDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCExplicitProtocolImplAttr>(mx::ObjCExplicitProtocolImplAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InjectedClassNameType>(mx::InjectedClassNameType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AbstractConditionalOperator>(mx::AbstractConditionalOperator) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InjectedClassNameType>>(gap::generator<mx::InjectedClassNameType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VarTemplateSpecializationDecl>>(gap::generator<mx::VarTemplateSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::SubIOp>(mx::ir::hl::SubIOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OverloadableAttr>>(std::optional<mx::OverloadableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::SubIAssignOp>(mx::ir::hl::SubIAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIvarRefExpr>>(std::optional<mx::ObjCIvarRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BlockExpr>(mx::BlockExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VarTemplateSpecializationDecl>>(std::optional<mx::VarTemplateSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXBoolLiteralExpr>>(gap::generator<mx::CXXBoolLiteralExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCExceptionAttr>(mx::ObjCExceptionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::SubIAssignOp>>(std::optional<mx::ir::hl::SubIAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLAccessAttr>>(gap::generator<mx::OpenCLAccessAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InjectedClassNameType>>(std::optional<mx::InjectedClassNameType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConditionalOperator>(mx::ConditionalOperator) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<bool>>(std::optional<bool>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeRelatedAttr>(mx::ObjCBridgeRelatedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FieldDecl>(mx::FieldDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BinaryConditionalOperator>(mx::BinaryConditionalOperator) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FieldDecl>>(std::optional<mx::FieldDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLAccessAttr>>(std::optional<mx::OpenCLAccessAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXBoolLiteralExpr>>(std::optional<mx::CXXBoolLiteralExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRuntimeNameAttr>>(gap::generator<mx::ObjCRuntimeNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Operation>(mx::ir::Operation) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeMutableAttr>(mx::ObjCBridgeMutableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::SubIOp>>(std::optional<mx::ir::hl::SubIOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VAArgExpr>(mx::VAArgExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXBoolLiteralExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXBoolLiteralExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIsaExpr>>(gap::generator<mx::ObjCIsaExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::OperationKind>(mx::ir::OperationKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRuntimeVisibleAttr>>(gap::generator<mx::ObjCRuntimeVisibleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionType>(mx::FunctionType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AllocAlignAttrSpelling>(mx::AllocAlignAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionNoProtoType>(mx::FunctionNoProtoType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRuntimeVisibleAttr>>(std::optional<mx::ObjCRuntimeVisibleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionType>>(gap::generator<mx::FunctionType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeAttr>(mx::ObjCBridgeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::SubscriptOp>(mx::ir::hl::SubscriptOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnaryOperator>(mx::UnaryOperator) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::SubscriptOp>>(std::optional<mx::ir::hl::SubscriptOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIsaExpr>>(std::optional<mx::ObjCIsaExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionType>>(std::optional<mx::FunctionType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VarTemplatePartialSpecializationDecl>>(std::optional<mx::VarTemplatePartialSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateParamObjectDecl>(mx::TemplateParamObjectDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VarTemplatePartialSpecializationDecl>>(gap::generator<mx::VarTemplatePartialSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingDecl>>(gap::generator<mx::UsingDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedOnZeroAttr>(mx::OSReturnsRetainedOnZeroAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ThisOp>(mx::ir::hl::ThisOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnaryExprOrTypeTraitExpr>(mx::UnaryExprOrTypeTraitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::SwitchOp>(mx::ir::hl::SwitchOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRuntimeNameAttr>>(std::optional<mx::ObjCRuntimeNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::SwitchOp>>(std::optional<mx::ir::hl::SwitchOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedOnNonZeroAttr>(mx::OSReturnsRetainedOnNonZeroAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::Operation>>(std::optional<mx::ir::Operation>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypoExpr>(mx::TypoExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingDecl>>(std::optional<mx::UsingDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCEncodeExpr>>(gap::generator<mx::ObjCEncodeExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Result>(mx::ir::Result) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIndirectCopyRestoreExpr>>(gap::generator<mx::ObjCIndirectCopyRestoreExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Value>(mx::ir::Value) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCDirectAttr>>(gap::generator<mx::ObjCDirectAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ThisOp>>(std::optional<mx::ir::hl::ThisOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedAttr>(mx::OSReturnsRetainedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXBindTemporaryExpr>(mx::CXXBindTemporaryExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeTraitExpr>(mx::TypeTraitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BinaryOperator>(mx::BinaryOperator) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIndirectCopyRestoreExpr>>(std::optional<mx::ObjCIndirectCopyRestoreExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UsingDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::UsingDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXConversionDecl>>(gap::generator<mx::CXXConversionDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXBindTemporaryExpr>>(gap::generator<mx::CXXBindTemporaryExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCNonRuntimeProtocolAttr>>(gap::generator<mx::ObjCNonRuntimeProtocolAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionProtoType>(mx::FunctionProtoType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCNonRuntimeProtocolAttr>>(std::optional<mx::ObjCNonRuntimeProtocolAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentVectorType>(mx::DependentVectorType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXConversionDecl>>(std::optional<mx::CXXConversionDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionProtoType>>(gap::generator<mx::FunctionProtoType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsNotRetainedAttr>(mx::OSReturnsNotRetainedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::ValueKind>(mx::ir::ValueKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SubstNonTypeTemplateParmPackExpr>(mx::SubstNonTypeTemplateParmPackExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TranslationUnitOp>(mx::ir::hl::TranslationUnitOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCNonLazyClassAttr>>(gap::generator<mx::ObjCNonLazyClassAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Type>(mx::ir::Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSConsumesThisAttr>(mx::OSConsumesThisAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TranslationUnitOp>>(std::optional<mx::ir::hl::TranslationUnitOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NonTypeTemplateParmDecl>(mx::NonTypeTemplateParmDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionProtoType>>(std::optional<mx::FunctionProtoType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCEncodeExpr>>(std::optional<mx::ObjCEncodeExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::TypeKind>(mx::ir::TypeKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCNonLazyClassAttr>>(std::optional<mx::ObjCNonLazyClassAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXBindTemporaryExpr>>(std::optional<mx::CXXBindTemporaryExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCDirectMembersAttr>>(gap::generator<mx::ObjCDirectMembersAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TypeAliasOp>(mx::ir::hl::TypeAliasOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPThreadPrivateDeclAttr>(mx::OMPThreadPrivateDeclAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXBindTemporaryExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXBindTemporaryExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SubstNonTypeTemplateParmExpr>(mx::SubstNonTypeTemplateParmExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TypeAliasOp>>(std::optional<mx::ir::hl::TypeAliasOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBoxedExpr>>(gap::generator<mx::ObjCBoxedExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ir::Operand>>(gap::generator<mx::ir::Operand>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtDefsFieldDecl>>(gap::generator<mx::ObjCAtDefsFieldDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Operand>(mx::ir::Operand) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCDirectMembersAttr>>(std::optional<mx::ObjCDirectMembersAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TypeDefOp>(mx::ir::hl::TypeDefOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDeductionGuideDecl>>(gap::generator<mx::CXXDeductionGuideDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CanThrowResult>>(std::optional<mx::CanThrowResult>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareVariantAttr>(mx::OMPDeclareVariantAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TypeDeclOp>(mx::ir::hl::TypeDeclOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StmtExpr>(mx::StmtExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::Result>>(std::optional<mx::ir::Result>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCDictionaryLiteral>>(gap::generator<mx::ObjCDictionaryLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TypeDeclOp>>(std::optional<mx::ir::hl::TypeDeclOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDeductionGuideDecl>>(std::optional<mx::CXXDeductionGuideDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedUsingValueDecl>>(gap::generator<mx::UnresolvedUsingValueDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCDictionaryLiteral>>(std::optional<mx::ObjCDictionaryLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedUsingValueDecl>(mx::UnresolvedUsingValueDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareTargetDeclAttr>(mx::OMPDeclareTargetDeclAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AssumeOp>>(std::optional<mx::ir::llvm::AssumeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SourceLocExpr>(mx::SourceLocExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSReturnsRetainedOnZeroAttr>>(std::optional<mx::OSReturnsRetainedOnZeroAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCDirectAttr>>(std::optional<mx::ObjCDirectAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::BitReverseOp>>(std::optional<mx::ir::llvm::BitReverseOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPCaptureNoInitAttr>(mx::OMPCaptureNoInitAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ScopedLockableAttr>>(gap::generator<mx::ScopedLockableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SizeOfPackExpr>(mx::SizeOfPackExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WebAssemblyImportNameAttr>>(std::optional<mx::WebAssemblyImportNameAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCClassStubAttr>>(gap::generator<mx::ObjCClassStubAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ByteSwapOp>(mx::ir::llvm::ByteSwapOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCDesignatedInitializerAttr>>(gap::generator<mx::ObjCDesignatedInitializerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ByteSwapOp>>(std::optional<mx::ir::llvm::ByteSwapOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPAllocateDeclAttr>(mx::OMPAllocateDeclAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ScopedLockableAttr>>(std::optional<mx::ScopedLockableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ShuffleVectorExpr>(mx::ShuffleVectorExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PseudoObjectExpr>>(gap::generator<mx::PseudoObjectExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCDesignatedInitializerAttr>>(std::optional<mx::ObjCDesignatedInitializerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSReturnsRetainedOnNonZeroAttr>>(gap::generator<mx::OSReturnsRetainedOnNonZeroAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBoxedExpr>>(std::optional<mx::ObjCBoxedExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WebAssemblyImportModuleAttr>>(gap::generator<mx::WebAssemblyImportModuleAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NotTailCalledAttr>(mx::NotTailCalledAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CopySignOp>(mx::ir::llvm::CopySignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SYCLUniqueStableNameExpr>(mx::SYCLUniqueStableNameExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CopySignOp>>(std::optional<mx::ir::llvm::CopySignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtDefsFieldDecl>>(std::optional<mx::ObjCAtDefsFieldDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PseudoObjectExpr>>(std::optional<mx::PseudoObjectExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Index>>(std::optional<mx::Index>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSReturnsRetainedOnNonZeroAttr>>(std::optional<mx::OSReturnsRetainedOnNonZeroAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCClassStubAttr>>(std::optional<mx::ObjCClassStubAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SYCLSpecialClassAttr>>(gap::generator<mx::SYCLSpecialClassAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoUwtableAttr>(mx::NoUwtableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::PseudoObjectExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::PseudoObjectExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBoxableAttr>>(gap::generator<mx::ObjCBoxableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroAlignOp>(mx::ir::llvm::CoroAlignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RequiresExpr>(mx::RequiresExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WebAssemblyImportModuleAttr>>(std::optional<mx::WebAssemblyImportModuleAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoUniqueAddressAttr>(mx::NoUniqueAddressAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroAlignOp>>(std::optional<mx::ir::llvm::CoroAlignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RequiresExprBodyDecl>(mx::RequiresExprBodyDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroBeginOp>(mx::ir::llvm::CoroBeginOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBoxableAttr>>(std::optional<mx::ObjCBoxableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroBeginOp>>(std::optional<mx::ir::llvm::CoroBeginOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBoolLiteralExpr>>(gap::generator<mx::ObjCBoolLiteralExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SYCLSpecialClassAttr>>(std::optional<mx::SYCLSpecialClassAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Compilation>>(gap::generator<mx::Compilation>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSReturnsRetainedAttr>>(gap::generator<mx::OSReturnsRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCaptureKindAttr>>(gap::generator<mx::OMPCaptureKindAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WebAssemblyExportNameAttr>>(gap::generator<mx::WebAssemblyExportNameAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclarativeDirectiveValueDecl>>(gap::generator<mx::OMPDeclarativeDirectiveValueDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroEndOp>(mx::ir::llvm::CoroEndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoThrowAttr>(mx::NoThrowAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroEndOp>>(std::optional<mx::ir::llvm::CoroEndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RecoveryExpr>(mx::RecoveryExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SYCLKernelAttr>(mx::SYCLKernelAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBoolLiteralExpr>>(std::optional<mx::ObjCBoolLiteralExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSReturnsRetainedAttr>>(std::optional<mx::OSReturnsRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclarativeDirectiveValueDecl>>(std::optional<mx::OMPDeclarativeDirectiveValueDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SYCLKernelAttr>>(gap::generator<mx::SYCLKernelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPReferencedVarAttr>>(gap::generator<mx::OMPReferencedVarAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WebAssemblyExportNameAttr>>(std::optional<mx::WebAssemblyExportNameAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoThreadSafetyAnalysisAttr>(mx::NoThreadSafetyAnalysisAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroFreeOp>(mx::ir::llvm::CoroFreeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PseudoObjectExpr>(mx::PseudoObjectExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroFreeOp>>(std::optional<mx::ir::llvm::CoroFreeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPReferencedVarAttr>>(std::optional<mx::OMPReferencedVarAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PredefinedExpr>>(gap::generator<mx::PredefinedExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareMapperDecl>>(gap::generator<mx::OMPDeclareMapperDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SYCLKernelAttr>>(std::optional<mx::SYCLKernelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareSimdDeclAttr>>(gap::generator<mx::OMPDeclareSimdDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroIdOp>(mx::ir::llvm::CoroIdOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoStackProtectorAttr>(mx::NoStackProtectorAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsNotRetainedAttr>(mx::OSReturnsNotRetainedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PredefinedExpr>(mx::PredefinedExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSReturnsNotRetainedAttr>>(gap::generator<mx::OSReturnsNotRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCArrayLiteral>>(gap::generator<mx::ObjCArrayLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroIdOp>>(std::optional<mx::ir::llvm::CoroIdOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareSimdDeclAttr>>(std::optional<mx::OMPDeclareSimdDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WeakRefAttr>(mx::WeakRefAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAvailabilityCheckExpr>>(gap::generator<mx::ObjCAvailabilityCheckExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WeakRefAttr>>(gap::generator<mx::WeakRefAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareMapperDecl>>(std::optional<mx::OMPDeclareMapperDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PredefinedExpr>>(std::optional<mx::PredefinedExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoSplitStackAttr>(mx::NoSplitStackAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroPromiseOp>(mx::ir::llvm::CoroPromiseOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParenListExpr>(mx::ParenListExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::PredefinedExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::PredefinedExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAvailabilityCheckExpr>>(std::optional<mx::ObjCAvailabilityCheckExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroPromiseOp>>(std::optional<mx::ir::llvm::CoroPromiseOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoSpeculativeLoadHardeningAttr>(mx::NoSpeculativeLoadHardeningAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReturnsTwiceAttr>(mx::ReturnsTwiceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParenExpr>(mx::ParenExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSReturnsNotRetainedAttr>>(std::optional<mx::OSReturnsNotRetainedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCaptureKindAttr>>(std::optional<mx::OMPCaptureKindAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroResumeOp>(mx::ir::llvm::CoroResumeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoEscapeAttr>>(gap::generator<mx::NoEscapeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReturnsTwiceAttr>>(gap::generator<mx::ReturnsTwiceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoSanitizeAttr>(mx::NoSanitizeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WeakRefAttr>>(std::optional<mx::WeakRefAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PackExpansionExpr>(mx::PackExpansionExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroResumeOp>>(std::optional<mx::ir::llvm::CoroResumeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCArrayLiteral>>(std::optional<mx::ObjCArrayLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroSaveOp>(mx::ir::llvm::CoroSaveOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingPackDecl>>(gap::generator<mx::UsingPackDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroSaveOp>>(std::optional<mx::ir::llvm::CoroSaveOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstructorUsingShadowDecl>>(gap::generator<mx::ConstructorUsingShadowDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReturnsTwiceAttr>>(std::optional<mx::ReturnsTwiceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoEscapeAttr>>(std::optional<mx::NoEscapeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSConsumesThisAttr>(mx::OSConsumesThisAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoReturnAttr>(mx::NoReturnAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSConsumesThisAttr>>(gap::generator<mx::OSConsumesThisAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedMemberExpr>(mx::UnresolvedMemberExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroSizeOp>(mx::ir::llvm::CoroSizeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstructorUsingShadowDecl>>(std::optional<mx::ConstructorUsingShadowDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroSizeOp>>(std::optional<mx::ir::llvm::CoroSizeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoBuiltinAttr>>(gap::generator<mx::NoBuiltinAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WeakImportAttr>(mx::WeakImportAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoRandomizeLayoutAttr>(mx::NoRandomizeLayoutAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WeakImportAttr>>(gap::generator<mx::WeakImportAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OffsetOfExpr>(mx::OffsetOfExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CosOp>(mx::ir::llvm::CosOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoBuiltinAttr>>(std::optional<mx::NoBuiltinAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReturnsNonNullAttr>(mx::ReturnsNonNullAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPIteratorExpr>>(gap::generator<mx::OMPIteratorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSConsumesThisAttr>>(std::optional<mx::OSConsumesThisAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::File>>(gap::generator<mx::File>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CoroSuspendOp>(mx::ir::llvm::CoroSuspendOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoProfileFunctionAttr>(mx::NoProfileFunctionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReturnsNonNullAttr>>(gap::generator<mx::ReturnsNonNullAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ModeAttr>>(gap::generator<mx::ModeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParenListExpr>(mx::ParenListExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCSubscriptRefExpr>(mx::ObjCSubscriptRefExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CoroSuspendOp>>(std::optional<mx::ir::llvm::CoroSuspendOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPIteratorExpr>>(std::optional<mx::OMPIteratorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PackExpansionExpr>(mx::PackExpansionExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingPackDecl>>(std::optional<mx::UsingPackDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParenListExpr>>(gap::generator<mx::ParenListExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoMips16Attr>(mx::NoMips16Attr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WeakImportAttr>>(std::optional<mx::WeakImportAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCStringLiteral>(mx::ObjCStringLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CosOp>>(std::optional<mx::ir::llvm::CosOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ModeAttr>>(std::optional<mx::ModeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReturnsNonNullAttr>>(std::optional<mx::ReturnsNonNullAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LoopHintAttr>>(gap::generator<mx::LoopHintAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParenListExpr>>(std::optional<mx::ParenListExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPArrayShapingExpr>>(gap::generator<mx::OMPArrayShapingExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPThreadPrivateDeclAttr>(mx::OMPThreadPrivateDeclAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoMicroMipsAttr>(mx::NoMicroMipsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareTargetDeclAttr>(mx::OMPDeclareTargetDeclAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCSelectorExpr>(mx::ObjCSelectorExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPThreadPrivateDeclAttr>>(gap::generator<mx::OMPThreadPrivateDeclAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingDirectiveDecl>>(gap::generator<mx::UsingDirectiveDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ParenListExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ParenListExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LoopHintAttr>>(std::optional<mx::LoopHintAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WeakAttr>(mx::WeakAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoInstrumentFunctionAttr>(mx::NoInstrumentFunctionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CountLeadingZerosOp>(mx::ir::llvm::CountLeadingZerosOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCProtocolExpr>(mx::ObjCProtocolExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WarnUnusedAttr>(mx::WarnUnusedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPArrayShapingExpr>>(std::optional<mx::OMPArrayShapingExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WeakAttr>>(gap::generator<mx::WeakAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<std::variant<mx::Macro, mx::Token, mx::Fragment>>>(gap::generator<std::variant<mx::Macro, mx::Token, mx::Fragment>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CountLeadingZerosOp>>(std::optional<mx::ir::llvm::CountLeadingZerosOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InitSegAttr>>(gap::generator<mx::InitSegAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReturnTypestateAttr>(mx::ReturnTypestateAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingDirectiveDecl>>(std::optional<mx::UsingDirectiveDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPThreadPrivateDeclAttr>>(std::optional<mx::OMPThreadPrivateDeclAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoDuplicateAttr>(mx::NoDuplicateAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RestrictAttr>(mx::RestrictAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCMessageExpr>(mx::ObjCMessageExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReturnTypestateAttr>>(gap::generator<mx::ReturnTypestateAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LoaderUninitializedAttr>>(gap::generator<mx::LoaderUninitializedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CtPopOp>(mx::ir::llvm::CtPopOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPArraySectionExpr>>(gap::generator<mx::OMPArraySectionExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CountTrailingZerosOp>(mx::ir::llvm::CountTrailingZerosOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LoaderUninitializedAttr>>(std::optional<mx::LoaderUninitializedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CountTrailingZerosOp>>(std::optional<mx::ir::llvm::CountTrailingZerosOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NamespaceDecl>>(gap::generator<mx::NamespaceDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WeakAttr>>(std::optional<mx::WeakAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoDestroyAttr>(mx::NoDestroyAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReturnTypestateAttr>>(std::optional<mx::ReturnTypestateAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCIvarRefExpr>(mx::ObjCIvarRefExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareVariantAttr>(mx::OMPDeclareVariantAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPArraySectionExpr>>(std::optional<mx::OMPArraySectionExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPCaptureNoInitAttr>(mx::OMPCaptureNoInitAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InitSegAttr>>(std::optional<mx::InitSegAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareVariantAttr>>(gap::generator<mx::OMPDeclareVariantAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoDebugAttr>(mx::NoDebugAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CtPopOp>>(std::optional<mx::ir::llvm::CtPopOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCIsaExpr>(mx::ObjCIsaExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WarnUnusedResultAttr>(mx::WarnUnusedResultAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NamespaceDecl>>(std::optional<mx::NamespaceDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParenExpr>(mx::ParenExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IBOutletCollectionAttr>>(gap::generator<mx::IBOutletCollectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VisibilityAttr>(mx::VisibilityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoInitExpr>>(gap::generator<mx::NoInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OffsetOfExpr>(mx::OffsetOfExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoCommonAttr>(mx::NoCommonAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WarnUnusedResultAttr>>(gap::generator<mx::WarnUnusedResultAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCIndirectCopyRestoreExpr>(mx::ObjCIndirectCopyRestoreExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParenExpr>>(gap::generator<mx::ParenExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IBOutletCollectionAttr>>(std::optional<mx::IBOutletCollectionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DbgLabelOp>(mx::ir::llvm::DbgLabelOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IBOutletAttr>>(gap::generator<mx::IBOutletAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DbgDeclareOp>(mx::ir::llvm::DbgDeclareOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoAliasAttr>(mx::NoAliasAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareVariantAttr>>(std::optional<mx::OMPDeclareVariantAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCEncodeExpr>(mx::ObjCEncodeExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DbgDeclareOp>>(std::optional<mx::ir::llvm::DbgDeclareOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoInitExpr>>(std::optional<mx::NoInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RetainAttr>(mx::RetainAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NakedAttr>(mx::NakedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RequiresCapabilityAttr>(mx::RequiresCapabilityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCDictionaryLiteral>(mx::ObjCDictionaryLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RetainAttr>>(gap::generator<mx::RetainAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IBOutletAttr>>(std::optional<mx::IBOutletAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::M68kInterruptAttr>>(std::optional<mx::M68kInterruptAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MemberExpr>>(gap::generator<mx::MemberExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLUnrollHintAttr>>(gap::generator<mx::OpenCLUnrollHintAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedUsingIfExistsDecl>>(gap::generator<mx::UnresolvedUsingIfExistsDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXForRangeStmt>>(gap::generator<mx::CXXForRangeStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IBActionAttr>>(gap::generator<mx::IBActionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Region>(mx::ir::Region) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedUsingIfExistsDecl>>(std::optional<mx::UnresolvedUsingIfExistsDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Block>(mx::ir::Block) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NVPTXKernelAttr>(mx::NVPTXKernelAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Argument>(mx::ir::Argument) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBoxedExpr>(mx::ObjCBoxedExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXForRangeStmt>>(std::optional<mx::CXXForRangeStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MemberExpr>>(std::optional<mx::MemberExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLUnrollHintAttr>>(std::optional<mx::OpenCLUnrollHintAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IBActionAttr>>(std::optional<mx::IBActionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::Argument>>(std::optional<mx::ir::Argument>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsRetainedAttr>(mx::NSReturnsRetainedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXForRangeStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXForRangeStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBoolLiteralExpr>(mx::ObjCBoolLiteralExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LocksExcludedAttr>>(gap::generator<mx::LocksExcludedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HotAttr>>(gap::generator<mx::HotAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::Block>>(std::optional<mx::ir::Block>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ClassTemplateSpecializationDecl>>(gap::generator<mx::ClassTemplateSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtFinallyStmt>(mx::ObjCAtFinallyStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsNotRetainedAttr>(mx::NSReturnsNotRetainedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtFinallyStmt>>(gap::generator<mx::ObjCAtFinallyStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCAvailabilityCheckExpr>(mx::ObjCAvailabilityCheckExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ir::Argument>>(gap::generator<mx::ir::Argument>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ClassTemplateSpecializationDecl>>(std::optional<mx::ClassTemplateSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ir::Operation>>(gap::generator<mx::ir::Operation>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HotAttr>>(std::optional<mx::HotAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ir::Label>>(gap::generator<mx::ir::Label>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLShaderAttr>>(gap::generator<mx::HLSLShaderAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Label>(mx::ir::Label) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsAutoreleasedAttr>(mx::NSReturnsAutoreleasedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MustTailAttr>>(gap::generator<mx::MustTailAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCArrayLiteral>(mx::ObjCArrayLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LocksExcludedAttr>>(std::optional<mx::LocksExcludedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MatrixSubscriptExpr>>(gap::generator<mx::MatrixSubscriptExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtFinallyStmt>>(std::optional<mx::ObjCAtFinallyStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MatrixSubscriptExpr>>(std::optional<mx::MatrixSubscriptExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::Region>>(std::optional<mx::ir::Region>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSErrorDomainAttr>(mx::NSErrorDomainAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCAtFinallyStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCAtFinallyStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPIteratorExpr>(mx::OMPIteratorExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ir::Block>>(gap::generator<mx::ir::Block>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLShaderAttr>>(std::optional<mx::HLSLShaderAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MustTailAttr>>(std::optional<mx::MustTailAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLResourceAttr>>(gap::generator<mx::HLSLResourceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LockReturnedAttr>>(gap::generator<mx::LockReturnedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSConsumesSelfAttr>(mx::NSConsumesSelfAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BreakStmt>(mx::BreakStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPArrayShapingExpr>(mx::OMPArrayShapingExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BreakStmt>>(gap::generator<mx::BreakStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLResourceBindingAttr>>(gap::generator<mx::HLSLResourceBindingAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LikelyAttr>(mx::LikelyAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ClassTemplatePartialSpecializationDecl>>(gap::generator<mx::ClassTemplatePartialSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LikelyAttr>>(gap::generator<mx::LikelyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLResourceBindingAttr>>(std::optional<mx::HLSLResourceBindingAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LockReturnedAttr>>(std::optional<mx::LockReturnedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MipsShortCallAttr>(mx::MipsShortCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::Operand>>(std::optional<mx::ir::Operand>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPArraySectionExpr>(mx::OMPArraySectionExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ir::Result>>(gap::generator<mx::ir::Result>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSPropertyRefExpr>>(gap::generator<mx::MSPropertyRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ir::Region>>(gap::generator<mx::ir::Region>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ClassTemplatePartialSpecializationDecl>>(std::optional<mx::ClassTemplatePartialSpecializationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BreakStmt>>(std::optional<mx::BreakStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MaterializeTemporaryExpr>>(gap::generator<mx::MaterializeTemporaryExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtCatchStmt>(mx::ObjCAtCatchStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MaterializeTemporaryExpr>>(std::optional<mx::MaterializeTemporaryExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtCatchStmt>>(std::optional<mx::ObjCAtCatchStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MipsLongCallAttr>(mx::MipsLongCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LikelyAttr>>(std::optional<mx::LikelyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoInitExpr>(mx::NoInitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtCatchStmt>>(gap::generator<mx::ObjCAtCatchStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLResourceAttr>>(std::optional<mx::HLSLResourceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::BreakStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::BreakStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLNumThreadsAttr>>(gap::generator<mx::HLSLNumThreadsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LifetimeBoundAttr>(mx::LifetimeBoundAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCExternallyRetainedAttrSpelling>(mx::ObjCExternallyRetainedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::Symbol>>(std::optional<mx::ir::Symbol>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDistributeParallelForSimdDirective>(mx::OMPDistributeParallelForSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LifetimeBoundAttr>>(gap::generator<mx::LifetimeBoundAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCGCAttrSpelling>(mx::ObjCGCAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::Symbol>(mx::ir::Symbol) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDistributeParallelForDirective>(mx::OMPDistributeParallelForDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeclaratorDecl>(mx::DeclaratorDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCIndependentClassAttrSpelling>(mx::ObjCIndependentClassAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FieldDecl>>(gap::generator<mx::FieldDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDistributeDirective>(mx::OMPDistributeDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FallThroughAttr>(mx::FallThroughAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCIvarDeclAccessControl>(mx::ObjCIvarDeclAccessControl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCAtCatchStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCAtCatchStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCMessageExprReceiverKind>(mx::ObjCMessageExprReceiverKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FallThroughAttr>>(gap::generator<mx::FallThroughAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsGenericLoopDirective>(mx::OMPTeamsGenericLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ValueDecl>(mx::ValueDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImplicitParamDecl>>(gap::generator<mx::ImplicitParamDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeclaratorDecl>>(gap::generator<mx::DeclaratorDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodFamilyAttrFamilyKind>(mx::ObjCMethodFamilyAttrFamilyKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LifetimeBoundAttr>>(std::optional<mx::LifetimeBoundAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDistributeSimdDirective>(mx::OMPTeamsDistributeSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NamedDecl>(mx::NamedDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodFamilyAttrSpelling>(mx::ObjCMethodFamilyAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NamedDecl>>(gap::generator<mx::NamedDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDistributeParallelForSimdDirective>(mx::OMPTeamsDistributeParallelForSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FallThroughAttr>>(std::optional<mx::FallThroughAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCNSObjectAttrSpelling>(mx::ObjCNSObjectAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AsmStmt>(mx::AsmStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCNonLazyClassAttrSpelling>(mx::ObjCNonLazyClassAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NamedDecl>>(std::optional<mx::NamedDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDistributeParallelForDirective>(mx::OMPTeamsDistributeParallelForDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GCCAsmStmt>(mx::GCCAsmStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCNonRuntimeProtocolAttrSpelling>(mx::ObjCNonRuntimeProtocolAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LeafAttr>(mx::LeafAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTeamsDistributeDirective>(mx::OMPTeamsDistributeDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AsmStmt>>(gap::generator<mx::AsmStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCOwnershipAttrSpelling>(mx::ObjCOwnershipAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LeafAttr>>(gap::generator<mx::LeafAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskLoopSimdDirective>(mx::OMPTaskLoopSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::NamedDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::NamedDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCPreciseLifetimeAttrSpelling>(mx::ObjCPreciseLifetimeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CodeAlignAttr>(mx::CodeAlignAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyDeclPropertyControl>(mx::ObjCPropertyDeclPropertyControl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AsmStmt>>(std::optional<mx::AsmStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTaskLoopDirective>(mx::OMPTaskLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CodeAlignAttr>>(gap::generator<mx::CodeAlignAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyDeclSetterKind>(mx::ObjCPropertyDeclSetterKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LeafAttr>>(std::optional<mx::LeafAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsGenericLoopDirective>(mx::OMPTargetTeamsGenericLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::AsmStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::AsmStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyImplDeclKind>(mx::ObjCPropertyImplDeclKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPExecutableDirective>(mx::OMPExecutableDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDistributeSimdDirective>(mx::OMPTargetTeamsDistributeSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtThrowStmt>>(gap::generator<mx::ObjCAtThrowStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRequiresPropertyDefsAttrSpelling>(mx::ObjCRequiresPropertyDefsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CodeAlignAttr>>(std::optional<mx::CodeAlignAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRequiresSuperAttrSpelling>(mx::ObjCRequiresSuperAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LayoutVersionAttr>(mx::LayoutVersionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDistributeParallelForSimdDirective>(mx::OMPTargetTeamsDistributeParallelForSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InternalLinkageAttr>(mx::InternalLinkageAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCReturnsInnerPointerAttrSpelling>(mx::ObjCReturnsInnerPointerAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LayoutVersionAttr>>(gap::generator<mx::LayoutVersionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMasterTaskLoopDirective>(mx::OMPParallelMasterTaskLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtThrowStmt>>(std::optional<mx::ObjCAtThrowStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRootClassAttrSpelling>(mx::ObjCRootClassAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCAtThrowStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCAtThrowStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDistributeParallelForDirective>(mx::OMPTargetTeamsDistributeParallelForDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCStringFormatFamily>>(std::optional<mx::ObjCStringFormatFamily>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRuntimeNameAttrSpelling>(mx::ObjCRuntimeNameAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Visibility>>(std::optional<mx::Visibility>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRuntimeVisibleAttrSpelling>(mx::ObjCRuntimeVisibleAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnlikelyAttr>(mx::UnlikelyAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetTeamsDistributeDirective>(mx::OMPTargetTeamsDistributeDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OverloadableAttr>(mx::OverloadableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCSubclassingRestrictedAttrSpelling>(mx::ObjCSubclassingRestrictedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnlikelyAttr>>(gap::generator<mx::UnlikelyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetSimdDirective>(mx::OMPTargetSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LayoutVersionAttr>>(std::optional<mx::LayoutVersionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLAccessAttrSpelling>(mx::OpenCLAccessAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ValueDecl>>(gap::generator<mx::ValueDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetParallelGenericLoopDirective>(mx::OMPTargetParallelGenericLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnlikelyAttr>>(std::optional<mx::UnlikelyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLConstantAddressSpaceAttrSpelling>(mx::OpenCLConstantAddressSpaceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ValueDecl>>(std::optional<mx::ValueDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGenericAddressSpaceAttrSpelling>(mx::OpenCLGenericAddressSpaceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::LTOVisibilityPublicAttr>(mx::LTOVisibilityPublicAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetParallelForSimdDirective>(mx::OMPTargetParallelForSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IntelOclBiccAttr>(mx::IntelOclBiccAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalAddressSpaceAttrSpelling>(mx::OpenCLGlobalAddressSpaceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSAsmStmt>(mx::MSAsmStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPTargetParallelForDirective>(mx::OMPTargetParallelForDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LTOVisibilityPublicAttr>>(gap::generator<mx::LTOVisibilityPublicAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling>(mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::WhileStmt>(mx::WhileStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPSimdDirective>(mx::OMPSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSAsmStmt>>(gap::generator<mx::MSAsmStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalHostAddressSpaceAttrSpelling>(mx::OpenCLGlobalHostAddressSpaceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ValueDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ValueDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLKernelAttrSpelling>(mx::OpenCLKernelAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPErrorDirective>(mx::OMPErrorDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMasterTaskLoopSimdDirective>(mx::OMPParallelMasterTaskLoopSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtSynchronizedStmt>>(gap::generator<mx::ObjCAtSynchronizedStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLLocalAddressSpaceAttrSpelling>(mx::OpenCLLocalAddressSpaceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RenderScriptKernelAttr>(mx::RenderScriptKernelAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMaskedTaskLoopSimdDirective>(mx::OMPParallelMaskedTaskLoopSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLAccessAttr>(mx::OpenCLAccessAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLPrivateAddressSpaceAttrSpelling>(mx::OpenCLPrivateAddressSpaceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RenderScriptKernelAttr>>(gap::generator<mx::RenderScriptKernelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMaskedTaskLoopDirective>(mx::OMPParallelMaskedTaskLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LTOVisibilityPublicAttr>>(std::optional<mx::LTOVisibilityPublicAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OptimizeNoneAttrSpelling>(mx::OptimizeNoneAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSAsmStmt>>(std::optional<mx::MSAsmStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OverloadableAttrSpelling>(mx::OverloadableAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::MSAsmStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::MSAsmStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelGenericLoopDirective>(mx::OMPParallelGenericLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtSynchronizedStmt>>(std::optional<mx::ObjCAtSynchronizedStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OwnershipAttrOwnershipKind>(mx::OwnershipAttrOwnershipKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPSIToFPOp>>(std::optional<mx::ir::llvm::VPSIToFPOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelForSimdDirective>(mx::OMPParallelForSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WarnUnusedResultAttr>>(std::optional<mx::WarnUnusedResultAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OwnershipAttrSpelling>(mx::OwnershipAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CDeclAttr>>(std::optional<mx::CDeclAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelForDirective>(mx::OMPParallelForDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Float128Type>>(std::optional<mx::ir::builtin::Float128Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PackedAttrSpelling>(mx::PackedAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LongLongType>>(std::optional<mx::ir::hl::LongLongType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParamTypestateAttrConsumedState>(mx::ParamTypestateAttrConsumedState) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::Int128Type>(mx::ir::hl::Int128Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPMasterTaskLoopSimdDirective>(mx::OMPMasterTaskLoopSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::FunctionType>(mx::ir::builtin::FunctionType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParamTypestateAttrSpelling>(mx::ParamTypestateAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMasterTaskLoopSimdDirective>>(std::optional<mx::OMPParallelMasterTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPMasterTaskLoopDirective>(mx::OMPMasterTaskLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::FunctionType>>(std::optional<mx::ir::builtin::FunctionType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PascalAttrSpelling>(mx::PascalAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::Int128Type>>(std::optional<mx::ir::hl::Int128Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPMaskedTaskLoopSimdDirective>(mx::OMPMaskedTaskLoopSimdDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPSRemOp>>(std::optional<mx::ir::llvm::VPSRemOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PassObjectSizeAttrSpelling>(mx::PassObjectSizeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::HalfType>(mx::ir::hl::HalfType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PatchableFunctionEntryAttrSpelling>(mx::PatchableFunctionEntryAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelMasterTaskLoopSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelMasterTaskLoopSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPMaskedTaskLoopDirective>(mx::OMPMaskedTaskLoopDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DisableTailCallsAttr>>(gap::generator<mx::DisableTailCallsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PcsAttrPCSType>(mx::PcsAttrPCSType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::IndexType>(mx::ir::builtin::IndexType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPInteropDirective>(mx::OMPInteropDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::HalfType>>(std::optional<mx::ir::hl::HalfType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PcsAttrSpelling>(mx::PcsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXReinterpretCastExpr>>(gap::generator<mx::CXXReinterpretCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPFlushDirective>(mx::OMPFlushDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::IndexType>>(std::optional<mx::ir::builtin::IndexType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PreferredNameAttrSpelling>(mx::PreferredNameAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::C11NoReturnAttr>>(gap::generator<mx::C11NoReturnAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PreferredTypeAttrSpelling>(mx::PreferredTypeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BFloat16Type>(mx::ir::hl::BFloat16Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPCanonicalLoop>(mx::OMPCanonicalLoop) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IntegerLiteral>>(gap::generator<mx::IntegerLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VarTemplateDecl>>(std::optional<mx::VarTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::IntegerType>(mx::ir::builtin::IntegerType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PreserveAllAttrSpelling>(mx::PreserveAllAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WarnUnusedAttr>>(gap::generator<mx::WarnUnusedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclRefExpr>(mx::DeclRefExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::IntegerType>>(std::optional<mx::ir::builtin::IntegerType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PreserveMostAttrSpelling>(mx::PreserveMostAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BFloat16Type>>(std::optional<mx::ir::hl::BFloat16Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NullStmt>(mx::NullStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPShlOp>(mx::ir::llvm::VPShlOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PtGuardedVarAttrSpelling>(mx::PtGuardedVarAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPSelectMinOp>(mx::ir::llvm::VPSelectMinOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PureAttrSpelling>(mx::PureAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FriendTemplateDecl>>(gap::generator<mx::FriendTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSDependentExistsStmt>(mx::MSDependentExistsStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::FloatType>(mx::ir::hl::FloatType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::QualifiedTypeDestructionKind>(mx::QualifiedTypeDestructionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPSelectMinOp>>(std::optional<mx::ir::llvm::VPSelectMinOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Decl>>(gap::generator<mx::Decl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DisableTailCallsAttr>>(std::optional<mx::DisableTailCallsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IndirectGotoStmt>(mx::IndirectGotoStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::FloatType>>(std::optional<mx::ir::hl::FloatType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParmVarDecl>>(gap::generator<mx::ParmVarDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXReinterpretCastExpr>>(std::optional<mx::CXXReinterpretCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::QualifiedTypeNonConstantStorageReason>(mx::QualifiedTypeNonConstantStorageReason) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::C11NoReturnAttr>>(std::optional<mx::C11NoReturnAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LabelDecl>(mx::LabelDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::MemRefType>(mx::ir::builtin::MemRefType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::QualifiedTypePrimitiveCopyKind>(mx::QualifiedTypePrimitiveCopyKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DoubleType>(mx::ir::hl::DoubleType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::QualifiedTypePrimitiveDefaultInitializeKind>(mx::QualifiedTypePrimitiveDefaultInitializeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IntegerLiteral>>(std::optional<mx::IntegerLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LabelStmt>(mx::LabelStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::MemRefType>>(std::optional<mx::ir::builtin::MemRefType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RISCVInterruptAttrInterruptType>(mx::RISCVInterruptAttrInterruptType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXReinterpretCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXReinterpretCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXTryStmt>(mx::CXXTryStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WarnUnusedAttr>>(std::optional<mx::WarnUnusedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RISCVInterruptAttrSpelling>(mx::RISCVInterruptAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DoubleType>>(std::optional<mx::ir::hl::DoubleType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IfStmt>(mx::IfStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::IntegerLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::IntegerLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RandomizeLayoutAttrSpelling>(mx::RandomizeLayoutAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FriendTemplateDecl>>(std::optional<mx::FriendTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReadOnlyPlacementAttrSpelling>(mx::ReadOnlyPlacementAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::LongDoubleType>(mx::ir::hl::LongDoubleType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclStmt>(mx::DeclStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::NoneType>(mx::ir::builtin::NoneType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RegCallAttrSpelling>(mx::RegCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPShlOp>>(std::optional<mx::ir::llvm::VPShlOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GotoStmt>(mx::GotoStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::NoneType>>(std::optional<mx::ir::builtin::NoneType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReinitializesAttrSpelling>(mx::ReinitializesAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FriendTemplateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::FriendTemplateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ForStmt>(mx::ForStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::LongDoubleType>>(std::optional<mx::ir::hl::LongDoubleType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReleaseCapabilityAttrSpelling>(mx::ReleaseCapabilityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::OpaqueType>(mx::ir::builtin::OpaqueType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReleaseHandleAttrSpelling>(mx::ReleaseHandleAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::Float128Type>(mx::ir::hl::Float128Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DoStmt>(mx::DoStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DisableSanitizerInstrumentationAttr>>(gap::generator<mx::DisableSanitizerInstrumentationAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RequiresCapabilityAttrSpelling>(mx::RequiresCapabilityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMasterTaskLoopDirective>>(gap::generator<mx::OMPParallelMasterTaskLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroutineBodyStmt>(mx::CoroutineBodyStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::OpaqueType>>(std::optional<mx::ir::builtin::OpaqueType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RestrictAttrSpelling>(mx::RestrictAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::Float128Type>>(std::optional<mx::ir::hl::Float128Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoreturnStmt>(mx::CoreturnStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinAttr>>(gap::generator<mx::BuiltinAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RetainAttrSpelling>(mx::RetainAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ComplexType>(mx::ir::hl::ComplexType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReturnTypestateAttrConsumedState>(mx::ReturnTypestateAttrConsumedState) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VisibilityAttr>>(gap::generator<mx::VisibilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ContinueStmt>(mx::ContinueStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::RankedTensorType>(mx::ir::builtin::RankedTensorType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReturnTypestateAttrSpelling>(mx::ReturnTypestateAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPStoreOp>(mx::ir::llvm::VPStoreOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXCatchStmt>(mx::CXXCatchStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::RankedTensorType>>(std::optional<mx::ir::builtin::RankedTensorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReturnsNonNullAttrSpelling>(mx::ReturnsNonNullAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPStoreOp>>(std::optional<mx::ir::llvm::VPStoreOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXForRangeStmt>(mx::CXXForRangeStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ComplexType>>(std::optional<mx::ir::hl::ComplexType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReturnsTwiceAttrSpelling>(mx::ReturnsTwiceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::TupleType>(mx::ir::builtin::TupleType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SYCLKernelAttrSpelling>(mx::SYCLKernelAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::PointerType>(mx::ir::hl::PointerType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BreakStmt>(mx::BreakStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DisableSanitizerInstrumentationAttr>>(std::optional<mx::DisableSanitizerInstrumentationAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SYCLSpecialClassAttrSpelling>(mx::SYCLSpecialClassAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMasterTaskLoopDirective>>(std::optional<mx::OMPParallelMasterTaskLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AsmStmt>(mx::AsmStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::TupleType>>(std::optional<mx::ir::builtin::TupleType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ScopedLockableAttrSpelling>(mx::ScopedLockableAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::PointerType>>(std::optional<mx::ir::hl::PointerType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSAsmStmt>(mx::MSAsmStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinAttr>>(std::optional<mx::BuiltinAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SectionAttrSpelling>(mx::SectionAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelMasterTaskLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelMasterTaskLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SelectAnyAttrSpelling>(mx::SelectAnyAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ArrayType>(mx::ir::hl::ArrayType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GCCAsmStmt>(mx::GCCAsmStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPStridedLoadOp>(mx::ir::llvm::VPStridedLoadOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SentinelAttrSpelling>(mx::SentinelAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VisibilityAttr>>(std::optional<mx::VisibilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StringLiteral>(mx::StringLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPStridedLoadOp>>(std::optional<mx::ir::llvm::VPStridedLoadOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SetTypestateAttrConsumedState>(mx::SetTypestateAttrConsumedState) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::UnrankedMemRefType>(mx::ir::builtin::UnrankedMemRefType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AddrLabelExpr>(mx::AddrLabelExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXFunctionalCastExpr>>(gap::generator<mx::CXXFunctionalCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SetTypestateAttrSpelling>(mx::SetTypestateAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ArrayType>>(std::optional<mx::ir::hl::ArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SpeculativeLoadHardeningAttrSpelling>(mx::SpeculativeLoadHardeningAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::UnrankedMemRefType>>(std::optional<mx::ir::builtin::UnrankedMemRefType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WhileStmt>(mx::WhileStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ImplicitValueInitExpr>(mx::ImplicitValueInitExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StandaloneDebugAttrSpelling>(mx::StandaloneDebugAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::VectorType>(mx::ir::hl::VectorType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DesignatedInitUpdateExpr>(mx::DesignatedInitUpdateExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImplicitValueInitExpr>>(gap::generator<mx::ImplicitValueInitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StdCallAttrSpelling>(mx::StdCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeclaratorDecl>>(std::optional<mx::DeclaratorDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InitListExpr>(mx::InitListExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::UnrankedTensorType>(mx::ir::builtin::UnrankedTensorType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StmtLikelihood>(mx::StmtLikelihood) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::VectorType>>(std::optional<mx::ir::hl::VectorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StmtKind>(mx::StmtKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DiagnoseIfAttr>(mx::DiagnoseIfAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DesignatedInitExpr>(mx::DesignatedInitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DeclaratorDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::DeclaratorDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SuppressAttrSpelling>(mx::SuppressAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPSubOp>(mx::ir::llvm::VPSubOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentScopeDeclRefExpr>(mx::DependentScopeDeclRefExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::UnrankedTensorType>>(std::optional<mx::ir::builtin::UnrankedTensorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncAttrKind>(mx::SwiftAsyncAttrKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DiagnoseIfAttr>>(gap::generator<mx::DiagnoseIfAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentCoawaitExpr>(mx::DependentCoawaitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPStridedStoreOp>(mx::ir::llvm::VPStridedStoreOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncAttrSpelling>(mx::SwiftAsyncAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::DecayedType>(mx::ir::hl::DecayedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncCallAttrSpelling>(mx::SwiftAsyncCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPStridedStoreOp>>(std::optional<mx::ir::llvm::VPStridedStoreOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedLookupExpr>(mx::UnresolvedLookupExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BlocksAttr>(mx::BlocksAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncContextAttrSpelling>(mx::SwiftAsyncContextAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::VectorType>(mx::ir::builtin::VectorType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OverloadExpr>(mx::OverloadExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BlocksAttr>>(gap::generator<mx::BlocksAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncErrorAttrConventionKind>(mx::SwiftAsyncErrorAttrConventionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXFunctionalCastExpr>>(std::optional<mx::CXXFunctionalCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroutineSuspendExpr>(mx::CoroutineSuspendExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FileScopeAsmDecl>(mx::FileScopeAsmDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncErrorAttrSpelling>(mx::SwiftAsyncErrorAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::DecayedType>>(std::optional<mx::ir::hl::DecayedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftCallAttrSpelling>(mx::SwiftCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FileScopeAsmDecl>>(gap::generator<mx::FileScopeAsmDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpaqueValueExpr>(mx::OpaqueValueExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::VectorType>>(std::optional<mx::ir::builtin::VectorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftContextAttrSpelling>(mx::SwiftContextAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VectorCallAttr>(mx::VectorCallAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoawaitExpr>(mx::CoawaitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AttributedType>(mx::ir::hl::AttributedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftErrorAttrConventionKind>(mx::SwiftErrorAttrConventionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VectorCallAttr>>(gap::generator<mx::VectorCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoyieldExpr>(mx::CoyieldExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXFunctionalCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXFunctionalCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftErrorResultAttrSpelling>(mx::SwiftErrorResultAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImplicitValueInitExpr>>(std::optional<mx::ImplicitValueInitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<uint32_t>(uint32_t) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AttributedType>>(std::optional<mx::ir::hl::AttributedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftIndirectResultAttrSpelling>(mx::SwiftIndirectResultAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ImplicitValueInitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ImplicitValueInitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConvertVectorExpr>(mx::ConvertVectorExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::UnrealizedConversionCastOp>(mx::ir::builtin::UnrealizedConversionCastOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftNewTypeAttrNewtypeKind>(mx::SwiftNewTypeAttrNewtypeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DiagnoseIfAttr>>(std::optional<mx::DiagnoseIfAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<uint64_t>(uint64_t) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AdjustedType>(mx::ir::hl::AdjustedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConceptSpecializationExpr>(mx::ConceptSpecializationExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::UnrealizedConversionCastOp>>(std::optional<mx::ir::builtin::UnrealizedConversionCastOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftNewTypeAttrSpelling>(mx::SwiftNewTypeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPSubOp>>(std::optional<mx::ir::llvm::VPSubOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ImplicitConceptSpecializationDecl>(mx::ImplicitConceptSpecializationDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BlocksAttr>>(std::optional<mx::BlocksAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SysVABIAttrSpelling>(mx::SysVABIAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AdjustedType>>(std::optional<mx::ir::hl::AdjustedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Stmt>>(std::optional<mx::Stmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FileScopeAsmDecl>>(std::optional<mx::FileScopeAsmDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<bool>(bool) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ReferenceType>(mx::ir::hl::ReferenceType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TLSModelAttrSpelling>(mx::TLSModelAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelGenericLoopDirective>(mx::OMPParallelGenericLoopDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CompoundLiteralExpr>(mx::CompoundLiteralExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VectorCallAttr>>(std::optional<mx::VectorCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TargetAttrSpelling>(mx::TargetAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMaskedTaskLoopSimdDirective>>(gap::generator<mx::OMPParallelMaskedTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ChooseExpr>(mx::ChooseExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FileScopeAsmDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::FileScopeAsmDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TargetClonesAttrSpelling>(mx::TargetClonesAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::Attribute>(mx::ir::llvm::Attribute) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CharacterLiteral>(mx::CharacterLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ReferenceType>>(std::optional<mx::ir::hl::ReferenceType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TargetVersionAttrSpelling>(mx::TargetVersionAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::Attribute>>(std::optional<mx::ir::llvm::Attribute>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AttrKind>(mx::AttrKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TypeOfExprType>(mx::ir::hl::TypeOfExprType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateArgumentKind>(mx::TemplateArgumentKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPTruncOp>(mx::ir::llvm::VPTruncOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CastExpr>(mx::CastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPTruncOp>>(std::optional<mx::ir::llvm::VPTruncOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TestTypestateAttrConsumedState>(mx::TestTypestateAttrConsumedState) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TypeOfExprType>>(std::optional<mx::ir::hl::TypeOfExprType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ImplicitCastExpr>(mx::ImplicitCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::CConvAttr>(mx::ir::llvm::CConvAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TestTypestateAttrSpelling>(mx::TestTypestateAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMaskedTaskLoopSimdDirective>>(std::optional<mx::OMPParallelMaskedTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AArch64SVEPcsAttrSpelling>(mx::AArch64SVEPcsAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::CConvAttr>>(std::optional<mx::ir::llvm::CConvAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclKind>(mx::DeclKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BTFDeclTagAttr>(mx::BTFDeclTagAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExplicitCastExpr>(mx::ExplicitCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TypeOfTypeType>(mx::ir::hl::TypeOfTypeType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ThisCallAttrSpelling>(mx::ThisCallAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DiagnoseAsBuiltinAttr>(mx::DiagnoseAsBuiltinAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TransparentUnionAttrSpelling>(mx::TransparentUnionAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BTFDeclTagAttr>>(gap::generator<mx::BTFDeclTagAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXNamedCastExpr>(mx::CXXNamedCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VecTypeHintAttr>(mx::VecTypeHintAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TrivialABIAttrSpelling>(mx::TrivialABIAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ComdatAttr>(mx::ir::llvm::ComdatAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXDynamicCastExpr>(mx::CXXDynamicCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DiagnoseAsBuiltinAttr>>(gap::generator<mx::DiagnoseAsBuiltinAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TryAcquireCapabilityAttrSpelling>(mx::TryAcquireCapabilityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelMaskedTaskLoopSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelMaskedTaskLoopSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TokenContext>(mx::TokenContext) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VecTypeHintAttr>>(gap::generator<mx::VecTypeHintAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXConstCastExpr>(mx::CXXConstCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TypeOfTypeType>>(std::optional<mx::ir::hl::TypeOfTypeType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeScalarTypeKind>(mx::TypeScalarTypeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ComdatAttr>>(std::optional<mx::ir::llvm::ComdatAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeKind>(mx::TypeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AutoType>(mx::ir::hl::AutoType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXAddrspaceCastExpr>(mx::CXXAddrspaceCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPUDivOp>(mx::ir::llvm::VPUDivOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeTagForDatatypeAttrSpelling>(mx::TypeTagForDatatypeAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CStyleCastExpr>(mx::CStyleCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXStaticCastExpr>(mx::CXXStaticCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgedCastExpr>(mx::ObjCBridgedCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeVisibilityAttrSpelling>(mx::TypeVisibilityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CStyleCastExpr>>(gap::generator<mx::CStyleCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXReinterpretCastExpr>(mx::CXXReinterpretCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LinkageAttr>(mx::ir::llvm::LinkageAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeVisibilityAttrVisibilityType>(mx::TypeVisibilityAttrVisibilityType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPUDivOp>>(std::optional<mx::ir::llvm::VPUDivOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<SpecificEntityId<DeclId>>>(std::optional<SpecificEntityId<DeclId>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GNUNullExpr>(mx::GNUNullExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnaryTransformTypeUTTKind>(mx::UnaryTransformTypeUTTKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AutoType>>(std::optional<mx::ir::hl::AutoType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXFunctionalCastExpr>(mx::CXXFunctionalCastExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImaginaryLiteral>>(gap::generator<mx::ImaginaryLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCGCAttr>(mx::ObjCGCAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LinkageAttr>>(std::optional<mx::ir::llvm::LinkageAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InitPriorityAttr>>(gap::generator<mx::InitPriorityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AtomicType>(mx::ir::hl::AtomicType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MemberExpr>(mx::MemberExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FramePointerKindAttr>(mx::ir::llvm::FramePointerKindAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BaseUsingDecl>>(gap::generator<mx::BaseUsingDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BTFDeclTagAttr>>(std::optional<mx::BTFDeclTagAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TagDecl>>(gap::generator<mx::TagDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DiagnoseAsBuiltinAttr>>(std::optional<mx::DiagnoseAsBuiltinAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoDerefAttr>(mx::NoDerefAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AtomicType>>(std::optional<mx::ir::hl::AtomicType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MatrixSubscriptExpr>(mx::MatrixSubscriptExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VecTypeHintAttr>>(std::optional<mx::VecTypeHintAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InitPriorityAttr>>(std::optional<mx::InitPriorityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FieldDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::FieldDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BaseUsingDecl>>(std::optional<mx::BaseUsingDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FramePointerKindAttr>>(std::optional<mx::ir::llvm::FramePointerKindAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CarriesDependencyAttr>>(gap::generator<mx::CarriesDependencyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::Operation>(mx::ir::hl::Operation) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TagDecl>>(std::optional<mx::TagDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::RefOp>(mx::ir::hl::RefOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLParamModifierAttr>(mx::HLSLParamModifierAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopVectorizeAttr>(mx::ir::llvm::LoopVectorizeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MaterializeTemporaryExpr>(mx::MaterializeTemporaryExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::Operation>>(std::optional<mx::ir::hl::Operation>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InheritableParamAttr>>(gap::generator<mx::InheritableParamAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CStyleCastExpr>>(std::optional<mx::CStyleCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCInterfaceType>>(gap::generator<mx::ObjCInterfaceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPUIToFPOp>(mx::ir::llvm::VPUIToFPOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLGroupSharedAddressSpaceAttr>(mx::HLSLGroupSharedAddressSpaceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImaginaryLiteral>>(std::optional<mx::ImaginaryLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypedefNameDecl>>(gap::generator<mx::TypedefNameDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EmptyDecl>(mx::EmptyDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LifetimeExtendedTemporaryDecl>(mx::LifetimeExtendedTemporaryDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPUIToFPOp>>(std::optional<mx::ir::llvm::VPUIToFPOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InheritableParamAttr>>(std::optional<mx::InheritableParamAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExternCContextDecl>>(gap::generator<mx::ExternCContextDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CarriesDependencyAttr>>(std::optional<mx::CarriesDependencyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CStyleCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CStyleCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCInterfaceType>>(std::optional<mx::ObjCInterfaceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopVectorizeAttr>>(std::optional<mx::ir::llvm::LoopVectorizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CmseNSCallAttr>(mx::CmseNSCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ImaginaryLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::ImaginaryLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSPropertySubscriptExpr>(mx::MSPropertySubscriptExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopInterleaveAttr>(mx::ir::llvm::LoopInterleaveAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCObjectPointerType>>(gap::generator<mx::ObjCObjectPointerType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::RefOp>>(std::optional<mx::ir::hl::RefOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypedefNameDecl>>(std::optional<mx::TypedefNameDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopInterleaveAttr>>(std::optional<mx::ir::llvm::LoopInterleaveAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedUsingType>>(gap::generator<mx::UnresolvedUsingType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AccessSpecifierOp>(mx::ir::hl::AccessSpecifierOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnnotateTypeAttr>(mx::AnnotateTypeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BPFPreserveStaticOffsetAttr>(mx::BPFPreserveStaticOffsetAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCObjectPointerType>>(std::optional<mx::ObjCObjectPointerType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AvailableOnlyInDefaultEvalMethodAttr>(mx::AvailableOnlyInDefaultEvalMethodAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSPropertyRefExpr>(mx::MSPropertyRefExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DestructorAttr>(mx::DestructorAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedUsingType>>(std::optional<mx::UnresolvedUsingType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopUnrollAttr>(mx::ir::llvm::LoopUnrollAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFConsumedAttr>>(std::optional<mx::CFConsumedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPXorOp>(mx::ir::llvm::VPXorOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BTFTypeTagAttr>(mx::BTFTypeTagAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BPFPreserveStaticOffsetAttr>>(gap::generator<mx::BPFPreserveStaticOffsetAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSPropertyDecl>(mx::MSPropertyDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeclOrStmtAttr>(mx::DeclOrStmtAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnnotateAttr>>(gap::generator<mx::AnnotateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DestructorAttr>>(gap::generator<mx::DestructorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Attr>>(gap::generator<mx::Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VecReturnAttr>(mx::VecReturnAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmStreamingCompatibleAttr>(mx::ArmStreamingCompatibleAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPURemOp>(mx::ir::llvm::VPURemOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnaryTransformType>>(std::optional<mx::UnaryTransformType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AccessSpecifierOp>>(std::optional<mx::ir::hl::AccessSpecifierOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LambdaExpr>(mx::LambdaExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UsingIfExistsAttr>(mx::UsingIfExistsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnnotateAttr>>(std::optional<mx::AnnotateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelMaskedTaskLoopDirective>(mx::OMPParallelMaskedTaskLoopDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedUsingTypenameDecl>>(gap::generator<mx::UnresolvedUsingTypenameDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VecReturnAttr>>(gap::generator<mx::VecReturnAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UseHandleAttr>>(gap::generator<mx::UseHandleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelForSimdDirective>(mx::OMPParallelForSimdDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmStreamingAttr>(mx::ArmStreamingAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMaskedTaskLoopDirective>>(gap::generator<mx::OMPParallelMaskedTaskLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IntegerLiteral>(mx::IntegerLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExternCContextDecl>>(std::optional<mx::ExternCContextDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedUsingTypenameDecl>>(std::optional<mx::UnresolvedUsingTypenameDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPURemOp>>(std::optional<mx::ir::llvm::VPURemOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmPreservesAttr>(mx::ArmPreservesAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopUnrollAttr>>(std::optional<mx::ir::llvm::LoopUnrollAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ImplicitValueInitExpr>(mx::ImplicitValueInitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AddFAssignOp>(mx::ir::hl::AddFAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UseHandleAttr>>(std::optional<mx::UseHandleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopUnrollAndJamAttr>(mx::ir::llvm::LoopUnrollAndJamAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeOfType>>(gap::generator<mx::TypeOfType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AddFOp>(mx::ir::hl::AddFOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReleaseHandleAttr>>(gap::generator<mx::ReleaseHandleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ExternCContextDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ExternCContextDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmOutAttr>(mx::ArmOutAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AddFAssignOp>>(std::optional<mx::ir::hl::AddFAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Token>>(gap::generator<mx::Token>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopUnrollAndJamAttr>>(std::optional<mx::ir::llvm::LoopUnrollAndJamAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ImaginaryLiteral>(mx::ImaginaryLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopLICMAttr>(mx::ir::llvm::LoopLICMAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypedefType>>(gap::generator<mx::TypedefType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BPFPreserveStaticOffsetAttr>>(std::optional<mx::BPFPreserveStaticOffsetAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReleaseHandleAttr>>(std::optional<mx::ReleaseHandleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DestructorAttr>>(std::optional<mx::DestructorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MemberPointerType>>(std::optional<mx::MemberPointerType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VecReturnAttr>>(std::optional<mx::VecReturnAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmMveStrictPolymorphismAttr>(mx::ArmMveStrictPolymorphismAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMaskedTaskLoopDirective>>(std::optional<mx::OMPParallelMaskedTaskLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GenericSelectionExpr>(mx::GenericSelectionExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopLICMAttr>>(std::optional<mx::ir::llvm::LoopLICMAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PassObjectSizeAttr>>(gap::generator<mx::PassObjectSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VariableArrayType>(mx::VariableArrayType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypedefType>>(std::optional<mx::TypedefType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPXorOp>>(std::optional<mx::ir::llvm::VPXorOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmInOutAttr>(mx::ArmInOutAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopDistributeAttr>(mx::ir::llvm::LoopDistributeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GNUNullExpr>(mx::GNUNullExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelMaskedTaskLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelMaskedTaskLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PassObjectSizeAttr>>(std::optional<mx::PassObjectSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VariableArrayType>>(std::optional<mx::VariableArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MatrixType>>(gap::generator<mx::MatrixType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArrayType>(mx::ArrayType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParameterABIAttr>>(gap::generator<mx::ParameterABIAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AddFOp>>(std::optional<mx::ir::hl::AddFOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmInAttr>(mx::ArmInAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArrayType>>(gap::generator<mx::ArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionParmPackExpr>(mx::FunctionParmPackExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopDistributeAttr>>(std::optional<mx::ir::llvm::LoopDistributeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RecordDecl>>(gap::generator<mx::RecordDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BuiltinBitCastExpr>(mx::BuiltinBitCastExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MatrixType>>(std::optional<mx::MatrixType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CallExpr>(mx::CallExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeOfType>>(std::optional<mx::TypeOfType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinBitCastExpr>>(gap::generator<mx::BuiltinBitCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RecordDecl>>(std::optional<mx::RecordDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopPipelineAttr>(mx::ir::llvm::LoopPipelineAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroQualifiedType>>(gap::generator<mx::MacroQualifiedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::GenericSelectionExpr>(mx::GenericSelectionExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SEHTryStmt>>(gap::generator<mx::SEHTryStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FunctionParmPackExpr>(mx::FunctionParmPackExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AddressSpaceAttr>(mx::AddressSpaceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GenericSelectionExpr>>(gap::generator<mx::GenericSelectionExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FullExpr>(mx::FullExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BPFPreserveAccessIndexAttr>(mx::BPFPreserveAccessIndexAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParameterABIAttr>>(std::optional<mx::ParameterABIAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopPipelineAttr>>(std::optional<mx::ir::llvm::LoopPipelineAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftContextAttr>>(gap::generator<mx::SwiftContextAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AvailabilityAttr>(mx::AvailabilityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeOfExprType>>(gap::generator<mx::TypeOfExprType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeprecatedAttr>(mx::DeprecatedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::WebAssemblyFuncrefAttr>(mx::WebAssemblyFuncrefAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BPFPreserveAccessIndexAttr>>(gap::generator<mx::BPFPreserveAccessIndexAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstantMatrixType>>(gap::generator<mx::ConstantMatrixType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AlwaysInlineAttr>(mx::AlwaysInlineAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExprWithCleanups>(mx::ExprWithCleanups) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArrayType>>(std::optional<mx::ArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftIndirectResultAttr>>(gap::generator<mx::SwiftIndirectResultAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeprecatedAttr>>(gap::generator<mx::DeprecatedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentSizedMatrixType>>(gap::generator<mx::DependentSizedMatrixType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UuidAttr>(mx::UuidAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeOfExprType>>(std::optional<mx::TypeOfExprType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VPZExtOp>(mx::ir::llvm::VPZExtOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftIndirectResultAttr>>(std::optional<mx::SwiftIndirectResultAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UsedAttr>(mx::UsedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentSizedMatrixType>>(std::optional<mx::DependentSizedMatrixType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopPeeledAttr>(mx::ir::llvm::LoopPeeledAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UPtrAttr>(mx::UPtrAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UuidAttr>>(gap::generator<mx::UuidAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstantExpr>(mx::ConstantExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AddIOp>(mx::ir::hl::AddIOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftErrorResultAttr>>(gap::generator<mx::SwiftErrorResultAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AddIAssignOp>(mx::ir::hl::AddIAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SEHTryStmt>>(std::optional<mx::SEHTryStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VPZExtOp>>(std::optional<mx::ir::llvm::VPZExtOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeNullableResultAttr>(mx::TypeNullableResultAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AddIAssignOp>>(std::optional<mx::ir::hl::AddIAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstantMatrixType>>(std::optional<mx::ConstantMatrixType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopPeeledAttr>>(std::optional<mx::ir::llvm::LoopPeeledAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FloatingLiteral>(mx::FloatingLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinBitCastExpr>>(std::optional<mx::BuiltinBitCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftErrorResultAttr>>(std::optional<mx::SwiftErrorResultAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopUnswitchAttr>(mx::ir::llvm::LoopUnswitchAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SEHExceptStmt>>(gap::generator<mx::SEHExceptStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GenericSelectionExpr>>(std::optional<mx::GenericSelectionExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeNullableAttr>(mx::TypeNullableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExportDecl>(mx::ExportDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FixedPointLiteral>(mx::FixedPointLiteral) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroSubstitution>(mx::MacroSubstitution) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroQualifiedType>>(std::optional<mx::MacroQualifiedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopUnswitchAttr>>(std::optional<mx::ir::llvm::LoopUnswitchAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftContextAttr>>(std::optional<mx::SwiftContextAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::BuiltinBitCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::BuiltinBitCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionType>>(gap::generator<mx::FunctionType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExportDecl>>(gap::generator<mx::ExportDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeNullUnspecifiedAttr>(mx::TypeNullUnspecifiedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BPFPreserveAccessIndexAttr>>(std::optional<mx::BPFPreserveAccessIndexAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExtVectorElementExpr>(mx::ExtVectorElementExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::GenericSelectionExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::GenericSelectionExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSConsumedAttr>>(gap::generator<mx::OSConsumedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeprecatedAttr>>(std::optional<mx::DeprecatedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SEHExceptStmt>>(std::optional<mx::SEHExceptStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LoopAnnotationAttr>(mx::ir::llvm::LoopAnnotationAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeNonNullAttr>(mx::TypeNonNullAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DIExpressionElemAttr>(mx::ir::llvm::DIExpressionElemAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncContextAttr>>(gap::generator<mx::SwiftAsyncContextAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VaCopyOp>(mx::ir::llvm::VaCopyOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InjectedClassNameType>>(gap::generator<mx::InjectedClassNameType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AddrLabelExprOp>(mx::ir::hl::AddrLabelExprOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExpressionTraitExpr>(mx::ExpressionTraitExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UuidAttr>>(std::optional<mx::UuidAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncContextAttr>>(std::optional<mx::SwiftAsyncContextAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VaEndOp>(mx::ir::llvm::VaEndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InjectedClassNameType>>(std::optional<mx::InjectedClassNameType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VariableArrayType>>(gap::generator<mx::VariableArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CompoundStmt>>(gap::generator<mx::CompoundStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VaCopyOp>>(std::optional<mx::ir::llvm::VaCopyOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ThreadAttr>(mx::ThreadAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AddIOp>>(std::optional<mx::ir::hl::AddIOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AttributedStmt>(mx::AttributedStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LoopAnnotationAttr>>(std::optional<mx::ir::llvm::LoopAnnotationAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CompoundStmt>>(std::optional<mx::CompoundStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TypeDefOp>>(std::optional<mx::ir::hl::TypeDefOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftVersionedRemovalAttr>(mx::SwiftVersionedRemovalAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionNoProtoType>>(gap::generator<mx::FunctionNoProtoType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSConsumedAttr>>(std::optional<mx::OSConsumedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Compilation>>(gap::generator<mx::Compilation>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwitchStmt>(mx::SwitchStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RetainAttr>>(std::optional<mx::RetainAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NonNullAttr>>(gap::generator<mx::NonNullAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedUsingValueDecl>>(std::optional<mx::UnresolvedUsingValueDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionType>>(std::optional<mx::FunctionType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareTargetDeclAttr>>(gap::generator<mx::OMPDeclareTargetDeclAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXRecordDecl>>(gap::generator<mx::CXXRecordDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedCompilationId>(PackedCompilationId) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionProtoType>>(gap::generator<mx::FunctionProtoType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BlockExpr>>(gap::generator<mx::BlockExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftVersionedAdditionAttr>(mx::SwiftVersionedAdditionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TypeOfExprOp>(mx::ir::hl::TypeOfExprOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwitchCase>(mx::SwitchCase) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionNoProtoType>>(std::optional<mx::FunctionNoProtoType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXRecordDecl>>(std::optional<mx::CXXRecordDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::ModuleOp>>(std::optional<mx::ir::builtin::ModuleOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NonNullAttr>>(std::optional<mx::NonNullAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UnresolvedUsingValueDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::UnresolvedUsingValueDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftObjCMembersAttr>(mx::SwiftObjCMembersAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::ModuleOp>(mx::ir::builtin::ModuleOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DefaultStmt>(mx::DefaultStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TypeOfExprOp>>(std::optional<mx::ir::hl::TypeOfExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSConsumedAttr>>(gap::generator<mx::NSConsumedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::builtin::Operation>(mx::ir::builtin::Operation) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionProtoType>>(std::optional<mx::FunctionProtoType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::builtin::Operation>>(std::optional<mx::ir::builtin::Operation>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SEHFinallyStmt>>(gap::generator<mx::SEHFinallyStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareTargetDeclAttr>>(std::optional<mx::OMPDeclareTargetDeclAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CanThrowResult>>(std::optional<mx::CanThrowResult>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BlockExpr>>(std::optional<mx::BlockExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StmtAttr>(mx::StmtAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::TypeYieldOp>(mx::ir::hl::TypeYieldOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SEHFinallyStmt>>(std::optional<mx::SEHFinallyStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RestrictAttr>>(gap::generator<mx::RestrictAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CaseStmt>(mx::CaseStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::TypeYieldOp>>(std::optional<mx::ir::hl::TypeYieldOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSConsumedAttr>>(std::optional<mx::NSConsumedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelDirective>>(gap::generator<mx::OMPParallelDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReferenceType>>(gap::generator<mx::ReferenceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::BlockExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::BlockExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLUnrollHintAttr>(mx::OpenCLUnrollHintAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentVectorType>>(gap::generator<mx::DependentVectorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AccessSpecDecl>(mx::AccessSpecDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DefineMacroDirective>(mx::DefineMacroDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReturnStmt>>(gap::generator<mx::ReturnStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::UnionDeclOp>(mx::ir::hl::UnionDeclOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IFuncAttr>>(gap::generator<mx::IFuncAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DefineMacroDirective>>(gap::generator<mx::DefineMacroDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MustTailAttr>(mx::MustTailAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::UnionDeclOp>>(std::optional<mx::ir::hl::UnionDeclOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SEHLeaveStmt>>(gap::generator<mx::SEHLeaveStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RestrictAttr>>(std::optional<mx::RestrictAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclarativeDirectiveDecl>(mx::OMPDeclarativeDirectiveDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentVectorType>>(std::optional<mx::DependentVectorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<std::vector<mx::CXXBaseSpecifier>>>(std::optional<std::vector<mx::CXXBaseSpecifier>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroDirective>(mx::MacroDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IFuncAttr>>(std::optional<mx::IFuncAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelDirective>>(std::optional<mx::OMPParallelDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSInheritanceModel>>(std::optional<mx::MSInheritanceModel>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroDirective>>(gap::generator<mx::MacroDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CalledOnceAttr>>(gap::generator<mx::CalledOnceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LikelyAttr>(mx::LikelyAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCaptureNoInitAttr>>(gap::generator<mx::OMPCaptureNoInitAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SEHLeaveStmt>>(std::optional<mx::SEHLeaveStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::UnreachableOp>(mx::ir::hl::UnreachableOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPThreadPrivateDecl>(mx::OMPThreadPrivateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnnamedGlobalConstantDecl>>(gap::generator<mx::UnnamedGlobalConstantDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionDecl>>(gap::generator<mx::FunctionDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::UnreachableOp>>(std::optional<mx::ir::hl::UnreachableOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeducedType>>(gap::generator<mx::DeducedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::VAArgExprOp>(mx::ir::hl::VAArgExprOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FallThroughAttr>(mx::FallThroughAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RequiresCapabilityAttr>>(gap::generator<mx::RequiresCapabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPRequiresDecl>(mx::OMPRequiresDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroDirective>>(std::optional<mx::MacroDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CalledOnceAttr>>(std::optional<mx::CalledOnceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCaptureNoInitAttr>>(std::optional<mx::OMPCaptureNoInitAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionNoProtoType>>(gap::generator<mx::FunctionNoProtoType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentSizedExtVectorType>(mx::DependentSizedExtVectorType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinAliasAttr>>(gap::generator<mx::BuiltinAliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BlockDecl>(mx::BlockDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionDecl>>(std::optional<mx::FunctionDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentSizedExtVectorType>>(gap::generator<mx::DependentSizedExtVectorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CodeAlignAttr>(mx::CodeAlignAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::VAArgExprOp>>(std::optional<mx::ir::hl::VAArgExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionNoProtoType>>(std::optional<mx::FunctionNoProtoType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BlockDecl>>(gap::generator<mx::BlockDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReturnStmt>>(std::optional<mx::ReturnStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnnamedGlobalConstantDecl>>(std::optional<mx::UnnamedGlobalConstantDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPAllocateDecl>(mx::OMPAllocateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentSizedExtVectorType>>(std::optional<mx::DependentSizedExtVectorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentVectorType>>(gap::generator<mx::DependentVectorType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UnnamedGlobalConstantDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::UnnamedGlobalConstantDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinAliasAttr>>(std::optional<mx::BuiltinAliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ValueYieldOp>(mx::ir::hl::ValueYieldOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnlikelyAttr>(mx::UnlikelyAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RequiresCapabilityAttr>>(std::optional<mx::RequiresCapabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TranslationUnitDecl>(mx::TranslationUnitDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ValueYieldOp>>(std::optional<mx::ir::hl::ValueYieldOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtTryStmt>>(gap::generator<mx::ObjCAtTryStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPAllocateDeclAttr>(mx::OMPAllocateDeclAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentVectorType>>(std::optional<mx::DependentVectorType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BlockDecl>>(std::optional<mx::BlockDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RenderScriptKernelAttr>(mx::RenderScriptKernelAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPAllocateDeclAttr>>(gap::generator<mx::OMPAllocateDeclAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateTypeParmType>>(gap::generator<mx::TemplateTypeParmType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::WhileOp>(mx::ir::hl::WhileOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCForCollectionStmt>>(gap::generator<mx::ObjCForCollectionStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPOrderedDirective>>(gap::generator<mx::OMPOrderedDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionTemplateDecl>>(std::optional<mx::FunctionTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::BlockDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::BlockDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TopLevelStmtDecl>(mx::TopLevelStmtDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::VarDeclOp>(mx::ir::hl::VarDeclOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCForCollectionStmt>>(std::optional<mx::ObjCForCollectionStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::VarDeclOp>>(std::optional<mx::ir::hl::VarDeclOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateTypeParmType>>(std::optional<mx::TemplateTypeParmType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentBitIntType>(mx::DependentBitIntType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OverloadableAttr>(mx::OverloadableAttr) noexcept;
 
 template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentBitIntType>>(gap::generator<mx::DependentBitIntType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReqdWorkGroupSizeAttr>(mx::ReqdWorkGroupSizeAttr) noexcept;
-
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReqdWorkGroupSizeAttr>>(gap::generator<mx::ReqdWorkGroupSizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StaticAssertDecl>(mx::StaticAssertDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPAllocateDeclAttr>>(std::optional<mx::OMPAllocateDeclAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionTemplateDecl>>(gap::generator<mx::FunctionTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPOrderedDirective>>(std::optional<mx::OMPOrderedDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateTypeParmDecl>>(std::optional<mx::TemplateTypeParmDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DefineMacroDirective>>(std::optional<mx::DefineMacroDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentSizedExtVectorType>>(gap::generator<mx::DependentSizedExtVectorType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentBitIntType>>(std::optional<mx::DependentBitIntType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentSizedExtVectorType>>(std::optional<mx::DependentSizedExtVectorType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPOrderedDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPOrderedDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLAccessAttr>(mx::OpenCLAccessAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::WhileOp>>(std::optional<mx::ir::hl::WhileOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaDetectMismatchDecl>(mx::PragmaDetectMismatchDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPCapturedExprDecl>(mx::OMPCapturedExprDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TagType>>(gap::generator<mx::TagType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReqdWorkGroupSizeAttr>>(std::optional<mx::ReqdWorkGroupSizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateTypeParmDecl>>(gap::generator<mx::TemplateTypeParmDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateParamObjectDecl>>(gap::generator<mx::TemplateParamObjectDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRuntimeVisibleAttr>(mx::ObjCRuntimeVisibleAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NotTailCalledAttr>(mx::NotTailCalledAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentBitIntType>>(std::optional<mx::DependentBitIntType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::Attribute>(mx::ir::core::Attribute) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAutoreleasePoolStmt>>(gap::generator<mx::ObjCAutoreleasePoolStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NotTailCalledAttr>>(gap::generator<mx::NotTailCalledAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaCommentDecl>(mx::PragmaCommentDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::Attribute>>(std::optional<mx::ir::core::Attribute>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAutoreleasePoolStmt>>(std::optional<mx::ObjCAutoreleasePoolStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentAddressSpaceType>(mx::DependentAddressSpaceType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCRuntimeNameAttr>(mx::ObjCRuntimeNameAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::BooleanAttr>(mx::ir::core::BooleanAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLBufferDecl>(mx::HLSLBufferDecl) noexcept;
 
 template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentAddressSpaceType>>(gap::generator<mx::DependentAddressSpaceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateParamObjectDecl>>(std::optional<mx::TemplateParamObjectDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtTryStmt>>(std::optional<mx::ObjCAtTryStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::BooleanAttr>>(std::optional<mx::ir::core::BooleanAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCNonRuntimeProtocolAttr>(mx::ObjCNonRuntimeProtocolAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TemplateParamObjectDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TemplateParamObjectDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentAddressSpaceType>>(std::optional<mx::DependentAddressSpaceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NotTailCalledAttr>>(std::optional<mx::NotTailCalledAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsingEnumDecl>(mx::UsingEnumDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentAddressSpaceType>>(std::optional<mx::DependentAddressSpaceType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCNonLazyClassAttr>(mx::ObjCNonLazyClassAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReleaseCapabilityAttr>(mx::ReleaseCapabilityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnumDecl>(mx::EnumDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::IntegerAttr>(mx::ir::core::IntegerAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtFinallyStmt>>(gap::generator<mx::ObjCAtFinallyStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReleaseCapabilityAttr>>(gap::generator<mx::ReleaseCapabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeducedType>>(std::optional<mx::DeducedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::string_view>>(gap::generator<std::string_view>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCDirectMembersAttr>(mx::ObjCDirectMembersAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::IncludePathLocation, std::filesystem::path>>>(gap::generator<std::pair<mx::IncludePathLocation, std::filesystem::path>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnumConstantDecl>(mx::EnumConstantDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::IntegerAttr>>(std::optional<mx::ir::core::IntegerAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AutoType>>(gap::generator<mx::AutoType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPMetaDirective>(mx::OMPMetaDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateSpecializationType>>(gap::generator<mx::TemplateSpecializationType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPMaskedDirective>(mx::OMPMaskedDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtFinallyStmt>>(std::optional<mx::ObjCAtFinallyStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AtomicExpr>(mx::AtomicExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoBuiltinAttr>(mx::NoBuiltinAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IncludePathLocation>(mx::IncludePathLocation) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateSpecializationType>>(std::optional<mx::TemplateSpecializationType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMetaDirective>>(gap::generator<mx::OMPMetaDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsingDecl>(mx::UsingDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BinaryOperator>>(gap::generator<mx::BinaryOperator>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeducedTemplateSpecializationType>>(gap::generator<mx::DeducedTemplateSpecializationType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::FloatAttr>(mx::ir::core::FloatAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtCatchStmt>>(gap::generator<mx::ObjCAtCatchStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::FloatAttr>>(std::optional<mx::ir::core::FloatAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCDirectAttr>(mx::ObjCDirectAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoUwtableAttr>(mx::NoUwtableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedUsingValueDecl>(mx::UnresolvedUsingValueDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReleaseCapabilityAttr>>(std::optional<mx::ReleaseCapabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeducedTemplateSpecializationType>>(std::optional<mx::DeducedTemplateSpecializationType>) noexcept;
+
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AutoType>>(std::optional<mx::AutoType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoThrowAttr>(mx::NoThrowAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCDesignatedInitializerAttr>(mx::ObjCDesignatedInitializerAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoUwtableAttr>>(gap::generator<mx::NoUwtableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TagType>>(std::optional<mx::TagType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::VoidAttr>(mx::ir::core::VoidAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtCatchStmt>>(std::optional<mx::ObjCAtCatchStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMetaDirective>>(std::optional<mx::OMPMetaDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnnamedGlobalConstantDecl>(mx::UnnamedGlobalConstantDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BinaryOperator>>(std::optional<mx::BinaryOperator>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RecordType>>(gap::generator<mx::RecordType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeducedType>(mx::DeducedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCClassStubAttr>(mx::ObjCClassStubAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ComplexType>(mx::ComplexType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateParamObjectDecl>(mx::TemplateParamObjectDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeducedType>>(gap::generator<mx::DeducedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RecordType>>(std::optional<mx::RecordType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::VoidAttr>>(std::optional<mx::ir::core::VoidAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBoxableAttr>(mx::ObjCBoxableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPMetaDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPMetaDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareReductionDecl>(mx::OMPDeclareReductionDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::BinaryOperator, mx::ir::Operation>>>(gap::generator<std::pair<mx::BinaryOperator, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnumType>>(gap::generator<mx::EnumType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::SourceLanguageAttr>(mx::ir::core::SourceLanguageAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPReferencedVarAttr>(mx::OMPReferencedVarAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Index>>(std::optional<mx::Index>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtThrowStmt>>(gap::generator<mx::ObjCAtThrowStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeducedType>>(std::optional<mx::DeducedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPCapturedExprDecl>(mx::OMPCapturedExprDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::SourceLanguageAttr>>(std::optional<mx::ir::core::SourceLanguageAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnumType>>(std::optional<mx::EnumType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoUwtableAttr>>(std::optional<mx::NoUwtableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConceptDecl>>(gap::generator<mx::ConceptDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareReductionDecl>(mx::OMPDeclareReductionDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtThrowStmt>>(std::optional<mx::ObjCAtThrowStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VarTemplateSpecializationDecl>(mx::VarTemplateSpecializationDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareSimdDeclAttr>(mx::OMPDeclareSimdDeclAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareReductionDecl>>(gap::generator<mx::OMPDeclareReductionDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DecompositionDecl>(mx::DecompositionDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::GlobalLinkageKindAttr>(mx::ir::core::GlobalLinkageKindAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConceptDecl>>(std::optional<mx::ConceptDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::Type>(mx::ir::core::Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPCaptureKindAttr>(mx::OMPCaptureKindAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IndexStatus>(mx::IndexStatus) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SubstTemplateTypeParmType>>(gap::generator<mx::SubstTemplateTypeParmType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReinitializesAttr>(mx::ReinitializesAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPErrorDirective>>(gap::generator<mx::OMPErrorDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<uint8_t>(uint8_t) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BindingDecl>(mx::BindingDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReadOnlyPlacementAttr>(mx::ReadOnlyPlacementAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstTemplateTypeParmType>>(std::optional<mx::SubstTemplateTypeParmType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReinitializesAttr>>(gap::generator<mx::ReinitializesAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCAtSynchronizedStmt>>(gap::generator<mx::ObjCAtSynchronizedStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::GlobalLinkageKindAttr>>(std::optional<mx::ir::core::GlobalLinkageKindAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoEscapeAttr>(mx::NoEscapeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<FilePathMap>(FilePathMap) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VarTemplateSpecializationDecl>(mx::VarTemplateSpecializationDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::Type>>(std::optional<mx::ir::core::Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ComplexType>>(gap::generator<mx::ComplexType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclareReductionDecl>>(std::optional<mx::OMPDeclareReductionDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCAtSynchronizedStmt>>(std::optional<mx::ObjCAtSynchronizedStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::FunctionType>(mx::ir::core::FunctionType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Attr>>(std::optional<mx::Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeducedTemplateSpecializationType>(mx::DeducedTemplateSpecializationType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SubstTemplateTypeParmPackType>>(gap::generator<mx::SubstTemplateTypeParmPackType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoUniqueAddressAttr>(mx::NoUniqueAddressAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DecltypeType>>(gap::generator<mx::DecltypeType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DecltypeType>(mx::DecltypeType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ModeAttr>(mx::ModeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoThreadSafetyAnalysisAttr>(mx::NoThreadSafetyAnalysisAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VarTemplatePartialSpecializationDecl>(mx::VarTemplatePartialSpecializationDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::FunctionType>>(std::optional<mx::ir::core::FunctionType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstTemplateTypeParmPackType>>(std::optional<mx::SubstTemplateTypeParmPackType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoUniqueAddressAttr>>(gap::generator<mx::NoUniqueAddressAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReferenceType>>(std::optional<mx::ReferenceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeducedTemplateSpecializationType>>(gap::generator<mx::DeducedTemplateSpecializationType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DecltypeType>>(std::optional<mx::DecltypeType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedDeclId>(PackedDeclId) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LoopHintAttr>(mx::LoopHintAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReinitializesAttr>>(std::optional<mx::ReinitializesAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPExecutableDirective>>(gap::generator<mx::OMPExecutableDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDeclareReductionDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDeclareReductionDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXConversionDecl>(mx::CXXConversionDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeducedTemplateSpecializationType>>(std::optional<mx::DeducedTemplateSpecializationType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Compilation>>(std::optional<mx::Compilation>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPMasterDirective>(mx::OMPMasterDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::QualifiedType>>(gap::generator<mx::QualifiedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPLoopBasedDirective>(mx::OMPLoopBasedDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ComplexType>>(std::optional<mx::ComplexType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMasterDirective>>(gap::generator<mx::OMPMasterDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPExecutableDirective>>(std::optional<mx::OMPExecutableDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::Operation>(mx::ir::core::Operation) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LoaderUninitializedAttr>(mx::LoaderUninitializedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::Operation>>(std::optional<mx::ir::core::Operation>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXDeductionGuideDecl>(mx::CXXDeductionGuideDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoUniqueAddressAttr>>(std::optional<mx::NoUniqueAddressAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RValueReferenceType>>(gap::generator<mx::RValueReferenceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::BinLOrOp>(mx::ir::core::BinLOrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinType>>(gap::generator<mx::BuiltinType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RegCallAttr>(mx::RegCallAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXMethodDecl>>(gap::generator<mx::CXXMethodDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::BinLAndOp>(mx::ir::core::BinLAndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InitSegAttr>(mx::InitSegAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RandomizeLayoutAttr>(mx::RandomizeLayoutAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RValueReferenceType>>(std::optional<mx::RValueReferenceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RegCallAttr>>(gap::generator<mx::RegCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXMethodDecl>>(std::optional<mx::CXXMethodDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::BinLAndOp>>(std::optional<mx::ir::core::BinLAndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtDefsFieldDecl>(mx::ObjCAtDefsFieldDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMasterDirective>>(std::optional<mx::OMPMasterDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LValueReferenceType>>(gap::generator<mx::LValueReferenceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CompoundAssignOperator>(mx::CompoundAssignOperator) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinType>>(std::optional<mx::BuiltinType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AutoType>(mx::AutoType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CapturedStmt>>(gap::generator<mx::CapturedStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AsTypeExpr>(mx::AsTypeExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BlockPointerType>>(gap::generator<mx::BlockPointerType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CompoundAssignOperator>>(gap::generator<mx::CompoundAssignOperator>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IBOutletCollectionAttr>(mx::IBOutletCollectionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSInheritanceAttrSpelling>(mx::MSInheritanceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclarativeDirectiveValueDecl>(mx::OMPDeclarativeDirectiveValueDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSP430InterruptAttrSpelling>(mx::MSP430InterruptAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LValueReferenceType>>(std::optional<mx::LValueReferenceType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSStructAttrSpelling>(mx::MSStructAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CapturedStmt>>(std::optional<mx::CapturedStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParenExpr>>(std::optional<mx::ParenExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IBOutletAttr>(mx::IBOutletAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MayAliasAttrSpelling>(mx::MayAliasAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareMapperDecl>(mx::OMPDeclareMapperDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MaybeUndefAttrSpelling>(mx::MaybeUndefAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BlockPointerType>>(std::optional<mx::BlockPointerType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MicroMipsAttrSpelling>(mx::MicroMipsAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BitIntType>>(gap::generator<mx::BitIntType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ParenExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ParenExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IBActionAttr>(mx::IBActionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VaEndOp>>(std::optional<mx::ir::llvm::VaEndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::QualifiedType>>(std::optional<mx::QualifiedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MinSizeAttrSpelling>(mx::MinSizeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CapturedDecl>>(gap::generator<mx::CapturedDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MinVectorWidthAttrSpelling>(mx::MinVectorWidthAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstructorUsingShadowDecl>(mx::ConstructorUsingShadowDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Mips16AttrSpelling>(mx::Mips16AttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BitIntType>>(std::optional<mx::BitIntType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MipsInterruptAttrInterruptType>(mx::MipsInterruptAttrInterruptType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HotAttr>(mx::HotAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InternalLinkageAttr>>(gap::generator<mx::InternalLinkageAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsingPackDecl>(mx::UsingPackDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MipsInterruptAttrSpelling>(mx::MipsInterruptAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AtomicType>>(gap::generator<mx::AtomicType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VaStartOp>(mx::ir::llvm::VaStartOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CapturedDecl>>(std::optional<mx::CapturedDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MipsLongCallAttrSpelling>(mx::MipsLongCallAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLShaderAttr>(mx::HLSLShaderAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VaStartOp>>(std::optional<mx::ir::llvm::VaStartOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AttributedType>>(gap::generator<mx::AttributedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VarAnnotationOp>(mx::ir::llvm::VarAnnotationOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UsingDirectiveDecl>(mx::UsingDirectiveDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MipsShortCallAttrSpelling>(mx::MipsShortCallAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BTFTagAttributedType>>(gap::generator<mx::BTFTagAttributedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ModeAttrSpelling>(mx::ModeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLResourceBindingAttr>(mx::HLSLResourceBindingAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MustTailAttrSpelling>(mx::MustTailAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NamespaceDecl>(mx::NamespaceDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VarAnnotationOp>>(std::optional<mx::ir::llvm::VarAnnotationOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BTFTagAttributedType>>(std::optional<mx::BTFTagAttributedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSConsumedAttrSpelling>(mx::NSConsumedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLResourceAttr>(mx::HLSLResourceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InternalLinkageAttr>>(std::optional<mx::InternalLinkageAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedUsingIfExistsDecl>(mx::UnresolvedUsingIfExistsDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSConsumesSelfAttrSpelling>(mx::NSConsumesSelfAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Fragment>>(gap::generator<mx::Fragment>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBridgedCastExpr>>(gap::generator<mx::ObjCBridgedCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AttributedType>>(std::optional<mx::AttributedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsAutoreleasedAttrSpelling>(mx::NSReturnsAutoreleasedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXConstructorDecl>>(gap::generator<mx::CXXConstructorDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MaskedCompressStoreOp>(mx::ir::llvm::MaskedCompressStoreOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<std::filesystem::path>>(gap::generator<std::filesystem::path>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsNotRetainedAttrSpelling>(mx::NSReturnsNotRetainedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLNumThreadsAttr>(mx::HLSLNumThreadsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSReturnsRetainedAttrSpelling>(mx::NSReturnsRetainedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NullabilityKind>>(std::optional<mx::NullabilityKind>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NVPTXKernelAttrSpelling>(mx::NVPTXKernelAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXConstructorDecl>>(std::optional<mx::CXXConstructorDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NakedAttrSpelling>(mx::NakedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ClassTemplateSpecializationDecl>(mx::ClassTemplateSpecializationDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MaskedCompressStoreOp>>(std::optional<mx::ir::llvm::MaskedCompressStoreOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLAnnotationAttr>(mx::HLSLAnnotationAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NamedDeclExplicitVisibilityKind>(mx::NamedDeclExplicitVisibilityKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ClassTemplatePartialSpecializationDecl>(mx::ClassTemplatePartialSpecializationDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoBuiltinAttrSpelling>(mx::NoBuiltinAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPErrorDirective>>(std::optional<mx::OMPErrorDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoCommonAttrSpelling>(mx::NoCommonAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLSV_GroupIndexAttr>(mx::HLSLSV_GroupIndexAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MaskedExpandLoadOp>(mx::ir::llvm::MaskedExpandLoadOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AtomicType>>(std::optional<mx::AtomicType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DesignatedInitExpr>(mx::DesignatedInitExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypedefDecl>(mx::TypedefDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoDebugAttrSpelling>(mx::NoDebugAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AdjustedType>>(gap::generator<mx::AdjustedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GCCAsmStmt>>(gap::generator<mx::GCCAsmStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDepobjDirective>>(gap::generator<mx::OMPDepobjDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoDerefAttrSpelling>(mx::NoDerefAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HLSLSV_DispatchThreadIDAttr>(mx::HLSLSV_DispatchThreadIDAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoDestroyAttrSpelling>(mx::NoDestroyAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeAliasDecl>(mx::TypeAliasDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBridgedCastExpr>>(std::optional<mx::ObjCBridgedCastExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncompleteArrayType>>(gap::generator<mx::IncompleteArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MaskedExpandLoadOp>>(std::optional<mx::ir::llvm::MaskedExpandLoadOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDispatchDirective>>(gap::generator<mx::OMPDispatchDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoDuplicateAttrSpelling>(mx::NoDuplicateAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::HIPManagedAttr>(mx::HIPManagedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoEscapeAttrSpelling>(mx::NoEscapeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeAliasTemplateDecl>(mx::TypeAliasTemplateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoInlineAttrSpelling>(mx::NoInlineAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncompleteArrayType>>(std::optional<mx::IncompleteArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IntelOclBiccAttr>>(gap::generator<mx::IntelOclBiccAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentSizedArrayType>>(gap::generator<mx::DependentSizedArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PackExpansionExpr>>(gap::generator<mx::PackExpansionExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDispatchDirective>>(std::optional<mx::OMPDispatchDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoInstrumentFunctionAttrSpelling>(mx::NoInstrumentFunctionAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FriendDecl>>(gap::generator<mx::FriendDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCBridgedCastExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCBridgedCastExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GuardedVarAttr>(mx::GuardedVarAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoMergeAttrSpelling>(mx::NoMergeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BuiltinTemplateDecl>(mx::BuiltinTemplateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoMicroMipsAttrSpelling>(mx::NoMicroMipsAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentSizedArrayType>>(std::optional<mx::DependentSizedArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoMips16AttrSpelling>(mx::NoMips16AttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FriendDecl>>(std::optional<mx::FriendDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MaskedGatherOp>(mx::ir::llvm::MaskedGatherOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstantArrayType>>(gap::generator<mx::ConstantArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoProfileFunctionAttrSpelling>(mx::NoProfileFunctionAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GuardedByAttr>(mx::GuardedByAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoRandomizeLayoutAttrSpelling>(mx::NoRandomizeLayoutAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateTemplateParmDecl>(mx::TemplateTemplateParmDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GCCAsmStmt>>(std::optional<mx::GCCAsmStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDepobjDirective>>(std::optional<mx::OMPDepobjDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MaskedGatherOp>>(std::optional<mx::ir::llvm::MaskedGatherOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::GNUInlineAttr>(mx::GNUInlineAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoReturnAttrSpelling>(mx::NoReturnAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstantArrayType>>(std::optional<mx::ConstantArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoSanitizeAttrSpelling>(mx::NoSanitizeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCCompatibleAliasDecl>(mx::ObjCCompatibleAliasDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoSpeculativeLoadHardeningAttrSpelling>(mx::NoSpeculativeLoadHardeningAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionReturnThunksAttr>(mx::FunctionReturnThunksAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::GCCAsmStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::GCCAsmStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NamespaceAliasDecl>(mx::NamespaceAliasDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoSplitStackAttrSpelling>(mx::NoSplitStackAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PointerType>>(gap::generator<mx::PointerType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoStackProtectorAttrSpelling>(mx::NoStackProtectorAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AdjustedType>>(std::optional<mx::AdjustedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PackExpansionExpr>>(std::optional<mx::PackExpansionExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeWithKeyword>>(gap::generator<mx::TypeWithKeyword>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoThreadSafetyAnalysisAttrSpelling>(mx::NoThreadSafetyAnalysisAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCriticalDirective>>(gap::generator<mx::OMPCriticalDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IntelOclBiccAttr>>(std::optional<mx::IntelOclBiccAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<std::vector<mx::FriendDecl>>>(std::optional<std::vector<mx::FriendDecl>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoThrowAttrSpelling>(mx::NoThrowAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FormatAttr>(mx::FormatAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoUniqueAddressAttrSpelling>(mx::NoUniqueAddressAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LinkageSpecDecl>(mx::LinkageSpecDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoUwtableAttrSpelling>(mx::NoUwtableAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PointerType>>(std::optional<mx::PointerType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::PackExpansionExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::PackExpansionExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PipeType>>(gap::generator<mx::PipeType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NonNullAttrSpelling>(mx::NonNullAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DecayedType>>(gap::generator<mx::DecayedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NotTailCalledAttrSpelling>(mx::NotTailCalledAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCriticalDirective>>(std::optional<mx::OMPCriticalDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MaskedScatterOp>(mx::ir::llvm::MaskedScatterOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FormatArgAttr>(mx::FormatArgAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPAllocateDeclAttrAllocatorTypeTy>(mx::OMPAllocateDeclAttrAllocatorTypeTy) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ClassTemplateDecl>>(gap::generator<mx::ClassTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MaskedScatterOp>>(std::optional<mx::ir::llvm::MaskedScatterOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ImportDecl>(mx::ImportDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareSimdDeclAttrBranchStateTy>(mx::OMPDeclareSimdDeclAttrBranchStateTy) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DecayedType>>(std::optional<mx::DecayedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareTargetDeclAttrDevTypeTy>(mx::OMPDeclareTargetDeclAttrDevTypeTy) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PipeType>>(std::optional<mx::PipeType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareTargetDeclAttrMapTypeTy>(mx::OMPDeclareTargetDeclAttrMapTypeTy) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCancelDirective>>(gap::generator<mx::OMPCancelDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSConsumedAttrSpelling>(mx::OSConsumedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FlattenAttr>(mx::FlattenAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSConsumesThisAttrSpelling>(mx::OSConsumesThisAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ClassTemplateDecl>>(std::optional<mx::ClassTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InitPriorityAttr>(mx::InitPriorityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FriendTemplateDecl>(mx::FriendTemplateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InitPriorityAttr>>(gap::generator<mx::InitPriorityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParenType>>(gap::generator<mx::ParenType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsNotRetainedAttrSpelling>(mx::OSReturnsNotRetainedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeWithKeyword>>(std::optional<mx::TypeWithKeyword>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedAttrSpelling>(mx::OSReturnsRetainedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCancellationPointDirective>>(gap::generator<mx::OMPCancellationPointDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorExtractOp>(mx::ir::llvm::VectorExtractOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnforceTCBLeafAttr>(mx::EnforceTCBLeafAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedOnNonZeroAttrSpelling>(mx::OSReturnsRetainedOnNonZeroAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VectorType>>(gap::generator<mx::VectorType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSReturnsRetainedOnZeroAttrSpelling>(mx::OSReturnsRetainedOnZeroAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCancellationPointDirective>>(std::optional<mx::OMPCancellationPointDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorExtractOp>>(std::optional<mx::ir::llvm::VectorExtractOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParenType>>(std::optional<mx::ParenType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBoxableAttrSpelling>(mx::ObjCBoxableAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PackExpansionType>>(gap::generator<mx::PackExpansionType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CallExpr>>(gap::generator<mx::CallExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FlagEnumAttr>(mx::FlagEnumAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeAttrSpelling>(mx::ObjCBridgeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ElaboratedType>>(gap::generator<mx::ElaboratedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeMutableAttrSpelling>(mx::ObjCBridgeMutableAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FileScopeAsmDecl>(mx::FileScopeAsmDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeRelatedAttrSpelling>(mx::ObjCBridgeRelatedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ElaboratedType>>(std::optional<mx::ElaboratedType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCClassStubAttrSpelling>(mx::ObjCClassStubAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FinalAttr>(mx::FinalAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCDesignatedInitializerAttrSpelling>(mx::ObjCDesignatedInitializerAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExternCContextDecl>(mx::ExternCContextDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StringLiteral>(mx::StringLiteral) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PackExpansionType>>(std::optional<mx::PackExpansionType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCDirectAttrSpelling>(mx::ObjCDirectAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCancelDirective>>(std::optional<mx::OMPCancelDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCDirectMembersAttrSpelling>(mx::ObjCDirectMembersAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MemberPointerType>>(gap::generator<mx::MemberPointerType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InitPriorityAttr>>(std::optional<mx::InitPriorityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDestructorDecl>>(gap::generator<mx::CXXDestructorDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StringLiteral>>(gap::generator<mx::StringLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FastCallAttr>(mx::FastCallAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCExceptionAttrSpelling>(mx::ObjCExceptionAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentNameType>>(gap::generator<mx::DependentNameType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCExplicitProtocolImplAttrSpelling>(mx::ObjCExplicitProtocolImplAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExportDecl>(mx::ExportDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCExternallyRetainedAttrSpelling>(mx::ObjCExternallyRetainedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCTypeParamType>>(gap::generator<mx::ObjCTypeParamType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorInsertOp>(mx::ir::llvm::VectorInsertOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentTemplateSpecializationType>>(gap::generator<mx::DependentTemplateSpecializationType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCGCAttrSpelling>(mx::ObjCGCAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPBarrierDirective>>(gap::generator<mx::OMPBarrierDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CallExpr>>(std::optional<mx::CallExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDestructorDecl>>(std::optional<mx::CXXDestructorDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCIndependentClassAttrSpelling>(mx::ObjCIndependentClassAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentTemplateSpecializationType>>(std::optional<mx::DependentTemplateSpecializationType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorInsertOp>>(std::optional<mx::ir::llvm::VectorInsertOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExclusiveTrylockFunctionAttr>(mx::ExclusiveTrylockFunctionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCIvarDeclAccessControl>(mx::ObjCIvarDeclAccessControl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EmptyDecl>(mx::EmptyDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedMemberExpr>(mx::UnresolvedMemberExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCTypeParamType>>(std::optional<mx::ObjCTypeParamType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCMessageExprReceiverKind>(mx::ObjCMessageExprReceiverKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPBarrierDirective>>(std::optional<mx::OMPBarrierDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedMemberExpr>>(gap::generator<mx::UnresolvedMemberExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCTypeParamDecl>>(gap::generator<mx::ObjCTypeParamDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodFamilyAttrFamilyKind>(mx::ObjCMethodFamilyAttrFamilyKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExcludeFromExplicitInstantiationAttr>(mx::ExcludeFromExplicitInstantiationAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CallExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CallExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentNameType>>(std::optional<mx::DependentNameType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StringLiteral>>(std::optional<mx::StringLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPAtomicDirective>>(gap::generator<mx::OMPAtomicDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodFamilyAttrSpelling>(mx::ObjCMethodFamilyAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ErrorAttr>(mx::ErrorAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCNSObjectAttrSpelling>(mx::ObjCNSObjectAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCTypeParamDecl>>(std::optional<mx::ObjCTypeParamDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InheritableParamAttr>(mx::InheritableParamAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroSubstitution>(mx::MacroSubstitution) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::StringLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::StringLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VectorType>>(std::optional<mx::VectorType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InheritableParamAttr>>(gap::generator<mx::InheritableParamAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnaryTransformType>>(gap::generator<mx::UnaryTransformType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCNonLazyClassAttrSpelling>(mx::ObjCNonLazyClassAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnumExtensibilityAttr>(mx::EnumExtensibilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCNonRuntimeProtocolAttrSpelling>(mx::ObjCNonRuntimeProtocolAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroVAOpt>(mx::MacroVAOpt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceAddOp>(mx::ir::llvm::VectorReduceAddOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCObjectType>>(gap::generator<mx::ObjCObjectType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCOwnershipAttrSpelling>(mx::ObjCOwnershipAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPAtomicDirective>>(std::optional<mx::OMPAtomicDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCPreciseLifetimeAttrSpelling>(mx::ObjCPreciseLifetimeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateDecl>>(std::optional<mx::TemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnresolvedMemberExpr>>(std::optional<mx::UnresolvedMemberExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExtVectorType>>(gap::generator<mx::ExtVectorType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceAddOp>>(std::optional<mx::ir::llvm::VectorReduceAddOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnforceTCBAttr>(mx::EnforceTCBAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyDeclPropertyControl>(mx::ObjCPropertyDeclPropertyControl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LambdaCaptureDefault>>(std::optional<mx::LambdaCaptureDefault>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyDeclSetterKind>(mx::ObjCPropertyDeclSetterKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EmptyTokenTreeNode>(mx::EmptyTokenTreeNode) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyImplDeclKind>(mx::ObjCPropertyImplDeclKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCObjectType>>(std::optional<mx::ObjCObjectType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UnresolvedMemberExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::UnresolvedMemberExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExtVectorType>>(std::optional<mx::ExtVectorType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRequiresPropertyDefsAttrSpelling>(mx::ObjCRequiresPropertyDefsAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTeamsDirective>>(gap::generator<mx::OMPTeamsDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InheritableParamAttr>>(std::optional<mx::InheritableParamAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingType>>(gap::generator<mx::UsingType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRequiresSuperAttrSpelling>(mx::ObjCRequiresSuperAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AcquireHandleAttrSpelling>(mx::AcquireHandleAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceAndOp>(mx::ir::llvm::VectorReduceAndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnableIfAttr>(mx::EnableIfAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCReturnsInnerPointerAttrSpelling>(mx::ObjCReturnsInnerPointerAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TokenTokenTreeNode>(mx::TokenTokenTreeNode) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRootClassAttrSpelling>(mx::ObjCRootClassAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<std::vector<mx::NamedDecl>>>(std::optional<std::vector<mx::NamedDecl>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceAndOp>>(std::optional<mx::ir::llvm::VectorReduceAndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTeamsDirective>>(std::optional<mx::OMPTeamsDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRuntimeNameAttrSpelling>(mx::ObjCRuntimeNameAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AddressSpaceAttrSpelling>(mx::AddressSpaceAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRuntimeVisibleAttrSpelling>(mx::ObjCRuntimeVisibleAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EmptyBasesAttr>(mx::EmptyBasesAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCSubclassingRestrictedAttrSpelling>(mx::ObjCSubclassingRestrictedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingType>>(std::optional<mx::UsingType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLAccessAttrSpelling>(mx::OpenCLAccessAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ChoiceTokenTreeNode>(mx::ChoiceTokenTreeNode) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLConstantAddressSpaceAttrSpelling>(mx::OpenCLConstantAddressSpaceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<uint32_t>>(std::optional<uint32_t>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGenericAddressSpaceAttrSpelling>(mx::OpenCLGenericAddressSpaceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingShadowDecl>>(gap::generator<mx::UsingShadowDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalAddressSpaceAttrSpelling>(mx::OpenCLGlobalAddressSpaceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskDirective>>(gap::generator<mx::OMPTaskDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling>(mx::OpenCLGlobalDeviceAddressSpaceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DisableTailCallsAttr>(mx::DisableTailCallsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalHostAddressSpaceAttrSpelling>(mx::OpenCLGlobalHostAddressSpaceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SubstitutionTokenTreeNode>(mx::SubstitutionTokenTreeNode) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceFAddOp>(mx::ir::llvm::VectorReduceFAddOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskyieldDirective>>(gap::generator<mx::OMPTaskyieldDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLKernelAttrSpelling>(mx::OpenCLKernelAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingShadowDecl>>(std::optional<mx::UsingShadowDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceFAddOp>>(std::optional<mx::ir::llvm::VectorReduceFAddOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DisableSanitizerInstrumentationAttr>(mx::DisableSanitizerInstrumentationAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLLocalAddressSpaceAttrSpelling>(mx::OpenCLLocalAddressSpaceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SequenceTokenTreeNode>(mx::SequenceTokenTreeNode) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLPrivateAddressSpaceAttrSpelling>(mx::OpenCLPrivateAddressSpaceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskyieldDirective>>(std::optional<mx::OMPTaskyieldDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CarriesDependencyAttr>(mx::CarriesDependencyAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoThreadSafetyAnalysisAttr>>(gap::generator<mx::NoThreadSafetyAnalysisAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OptimizeNoneAttrSpelling>(mx::OptimizeNoneAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MipsInterruptAttr>(mx::MipsInterruptAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CarriesDependencyAttr>>(gap::generator<mx::CarriesDependencyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CommonAttr>>(std::optional<mx::CommonAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OverloadableAttrSpelling>(mx::OverloadableAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnalyzerNoReturnAttr>>(gap::generator<mx::AnalyzerNoReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OwnershipAttrOwnershipKind>(mx::OwnershipAttrOwnershipKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoThreadSafetyAnalysisAttr>>(std::optional<mx::NoThreadSafetyAnalysisAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OwnershipAttrSpelling>(mx::OwnershipAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ColdAttr>>(gap::generator<mx::ColdAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PackedAttrSpelling>(mx::PackedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoStackProtectorAttr>>(gap::generator<mx::NoStackProtectorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXOperatorCallExpr>(mx::CXXOperatorCallExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Mips16Attr>(mx::Mips16Attr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CUDAKernelCallExpr>(mx::CUDAKernelCallExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinBitCastExpr>>(std::optional<mx::BuiltinBitCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXOperatorCallExpr>>(gap::generator<mx::CXXOperatorCallExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnalyzerNoReturnAttr>>(std::optional<mx::AnalyzerNoReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceFMaxOp>(mx::ir::llvm::VectorReduceFMaxOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMaskedTaskLoopSimdDirective>>(gap::generator<mx::OMPMaskedTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceFMaxOp>>(std::optional<mx::ir::llvm::VectorReduceFMaxOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MinVectorWidthAttr>(mx::MinVectorWidthAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParamTypestateAttrConsumedState>(mx::ParamTypestateAttrConsumedState) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ColdAttr>>(std::optional<mx::ColdAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParamTypestateAttrSpelling>(mx::ParamTypestateAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoStackProtectorAttr>>(std::optional<mx::NoStackProtectorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PascalAttrSpelling>(mx::PascalAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMaskedTaskLoopSimdDirective>>(std::optional<mx::OMPMaskedTaskLoopSimdDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PassObjectSizeAttrSpelling>(mx::PassObjectSizeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBridgedCastExpr>>(gap::generator<mx::ObjCBridgedCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PatchableFunctionEntryAttrSpelling>(mx::PatchableFunctionEntryAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CodeSegAttr>>(gap::generator<mx::CodeSegAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCStringLiteral>(mx::ObjCStringLiteral) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlwaysDestroyAttr>>(std::optional<mx::AlwaysDestroyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CarriesDependencyAttr>>(std::optional<mx::CarriesDependencyAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUWavesPerEUAttrSpelling>(mx::AMDGPUWavesPerEUAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OffsetOfExpr>>(gap::generator<mx::OffsetOfExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Reference>>(gap::generator<mx::Reference>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PcsAttrPCSType>(mx::PcsAttrPCSType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AllocSizeAttr>>(gap::generator<mx::AllocSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PcsAttrSpelling>(mx::PcsAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MinSizeAttr>(mx::MinSizeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PreferredNameAttrSpelling>(mx::PreferredNameAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoSplitStackAttr>>(std::optional<mx::NoSplitStackAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AddrLabelExpr>(mx::AddrLabelExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPInteropDirective>>(gap::generator<mx::OMPInteropDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AddrLabelExpr>>(std::optional<mx::AddrLabelExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBridgedCastExpr>>(std::optional<mx::ObjCBridgedCastExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceFMaximumOp>(mx::ir::llvm::VectorReduceFMaximumOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CodeSegAttr>>(std::optional<mx::CodeSegAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXOperatorCallExpr>>(std::optional<mx::CXXOperatorCallExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ARMInterruptAttrInterruptType>(mx::ARMInterruptAttrInterruptType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PreferredTypeAttrSpelling>(mx::PreferredTypeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MicroMipsAttr>(mx::MicroMipsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AddrLabelExpr>>(gap::generator<mx::AddrLabelExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CodeModelAttr>>(gap::generator<mx::CodeModelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceFMaximumOp>>(std::optional<mx::ir::llvm::VectorReduceFMaximumOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AllocSizeAttr>>(std::optional<mx::AllocSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PreserveAllAttrSpelling>(mx::PreserveAllAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMaskedTaskLoopDirective>>(gap::generator<mx::OMPMaskedTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PreserveMostAttrSpelling>(mx::PreserveMostAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AllocAlignAttr>>(gap::generator<mx::AllocAlignAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PtGuardedVarAttrSpelling>(mx::PtGuardedVarAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoSanitizeAttr>>(gap::generator<mx::NoSanitizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXOperatorCallExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXOperatorCallExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMaskedTaskLoopDirective>>(std::optional<mx::OMPMaskedTaskLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PureAttrSpelling>(mx::PureAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CallExpr>>(gap::generator<mx::CallExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::QualifiedTypeDestructionKind>(mx::QualifiedTypeDestructionKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoSpeculativeLoadHardeningAttr>>(gap::generator<mx::NoSpeculativeLoadHardeningAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::QualifiedTypeNonConstantStorageReason>(mx::QualifiedTypeNonConstantStorageReason) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MaybeUndefAttr>(mx::MaybeUndefAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OffsetOfExpr>>(std::optional<mx::OffsetOfExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RegexQueryMatch>(mx::RegexQueryMatch) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::QualifiedTypePrimitiveCopyKind>(mx::QualifiedTypePrimitiveCopyKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CodeModelAttr>>(std::optional<mx::CodeModelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::QualifiedTypePrimitiveDefaultInitializeKind>(mx::QualifiedTypePrimitiveDefaultInitializeKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoSpeculativeLoadHardeningAttr>>(std::optional<mx::NoSpeculativeLoadHardeningAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CFConsumedAttr>(mx::CFConsumedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CmseNSEntryAttr>>(gap::generator<mx::CmseNSEntryAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceFMinOp>(mx::ir::llvm::VectorReduceFMinOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AllocAlignAttr>>(std::optional<mx::AllocAlignAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RISCVInterruptAttrInterruptType>(mx::RISCVInterruptAttrInterruptType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MayAliasAttr>(mx::MayAliasAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UseHandleAttr>(mx::UseHandleAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CallExpr>>(std::optional<mx::CallExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OffsetOfExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::OffsetOfExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NamedDecl>>(std::optional<mx::NamedDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFConsumedAttr>>(gap::generator<mx::CFConsumedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoSanitizeAttr>>(std::optional<mx::NoSanitizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceFMinOp>>(std::optional<mx::ir::llvm::VectorReduceFMinOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPInteropDirective>>(std::optional<mx::OMPInteropDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RISCVInterruptAttrSpelling>(mx::RISCVInterruptAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MaxFieldAlignmentAttr>(mx::MaxFieldAlignmentAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RandomizeLayoutAttrSpelling>(mx::RandomizeLayoutAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CmseNSEntryAttr>>(std::optional<mx::CmseNSEntryAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::AddrLabelExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::AddrLabelExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlignedAttr>>(std::optional<mx::AlignedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReadOnlyPlacementAttrSpelling>(mx::ReadOnlyPlacementAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoReturnAttr>>(gap::generator<mx::NoReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RegCallAttrSpelling>(mx::RegCallAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCStringFormatFamily>>(std::optional<mx::ObjCStringFormatFamily>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReinitializesAttrSpelling>(mx::ReinitializesAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPFlushDirective>>(gap::generator<mx::OMPFlushDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReleaseCapabilityAttrSpelling>(mx::ReleaseCapabilityAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSVtorDispAttr>(mx::MSVtorDispAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReleaseHandleAttrSpelling>(mx::ReleaseHandleAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Expr>>(gap::generator<mx::Expr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceFMinimumOp>(mx::ir::llvm::VectorReduceFMinimumOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CleanupAttr>>(std::optional<mx::CleanupAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RequiresCapabilityAttrSpelling>(mx::RequiresCapabilityAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoReturnAttr>>(std::optional<mx::NoReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RestrictAttrSpelling>(mx::RestrictAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssumeAlignedAttr>>(gap::generator<mx::AssumeAlignedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceFMinimumOp>>(std::optional<mx::ir::llvm::VectorReduceFMinimumOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoMips16Attr>>(gap::generator<mx::NoMips16Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RetainAttrSpelling>(mx::RetainAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSStructAttr>(mx::MSStructAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFConsumedAttr>>(std::optional<mx::CFConsumedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlignNaturalAttr>>(gap::generator<mx::AlignNaturalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReturnTypestateAttrConsumedState>(mx::ReturnTypestateAttrConsumedState) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPFlushDirective>>(std::optional<mx::OMPFlushDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReturnTypestateAttrSpelling>(mx::ReturnTypestateAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TokenRange>(mx::TokenRange) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReturnsNonNullAttrSpelling>(mx::ReturnsNonNullAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXOperatorCallExpr>>(gap::generator<mx::CXXOperatorCallExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReturnsTwiceAttrSpelling>(mx::ReturnsTwiceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCPropertyRefExpr>>(gap::generator<mx::ObjCPropertyRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SYCLKernelAttrSpelling>(mx::SYCLKernelAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CapturedRecordAttr>>(gap::generator<mx::CapturedRecordAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SYCLSpecialClassAttrSpelling>(mx::SYCLSpecialClassAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoRandomizeLayoutAttr>>(gap::generator<mx::NoRandomizeLayoutAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceMulOp>(mx::ir::llvm::VectorReduceMulOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlignNaturalAttr>>(std::optional<mx::AlignNaturalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ScopedLockableAttrSpelling>(mx::ScopedLockableAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoRandomizeLayoutAttr>>(std::optional<mx::NoRandomizeLayoutAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceFMulOp>(mx::ir::llvm::VectorReduceFMulOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSP430InterruptAttr>(mx::MSP430InterruptAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SectionAttrSpelling>(mx::SectionAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXOperatorCallExpr>>(std::optional<mx::CXXOperatorCallExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceFMulOp>>(std::optional<mx::ir::llvm::VectorReduceFMulOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CapturedRecordAttr>>(std::optional<mx::CapturedRecordAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SelectAnyAttrSpelling>(mx::SelectAnyAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlignMac68kAttr>>(gap::generator<mx::AlignMac68kAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SentinelAttrSpelling>(mx::SentinelAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCanonicalLoop>>(gap::generator<mx::OMPCanonicalLoop>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SetTypestateAttrConsumedState>(mx::SetTypestateAttrConsumedState) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CapabilityAttr>>(gap::generator<mx::CapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXMemberCallExpr>(mx::CXXMemberCallExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoProfileFunctionAttr>>(gap::generator<mx::NoProfileFunctionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UserDefinedLiteral>(mx::UserDefinedLiteral) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSNoVTableAttr>(mx::MSNoVTableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SetTypestateAttrSpelling>(mx::SetTypestateAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlignMac68kAttr>>(std::optional<mx::AlignMac68kAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXMemberCallExpr>>(gap::generator<mx::CXXMemberCallExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoProfileFunctionAttr>>(std::optional<mx::NoProfileFunctionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AnnotateAttr>(mx::AnnotateAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCanonicalLoop>>(std::optional<mx::OMPCanonicalLoop>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SpeculativeLoadHardeningAttrSpelling>(mx::SpeculativeLoadHardeningAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSInheritanceAttr>(mx::MSInheritanceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ReleaseHandleAttr>(mx::ReleaseHandleAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CapabilityAttr>>(std::optional<mx::CapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnnotateAttr>>(gap::generator<mx::AnnotateAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AcquiredBeforeAttr>>(gap::generator<mx::AcquiredBeforeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StandaloneDebugAttrSpelling>(mx::StandaloneDebugAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CallbackAttr>>(gap::generator<mx::CallbackAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCSelectorExpr>(mx::ObjCSelectorExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXMemberCallExpr>>(gap::generator<mx::CXXMemberCallExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::StdCallAttrSpelling>(mx::StdCallAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeclRefExpr>>(gap::generator<mx::DeclRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCSubscriptRefExpr>(mx::ObjCSubscriptRefExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSConstexprAttr>(mx::MSConstexprAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceOrOp>(mx::ir::llvm::VectorReduceOrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AcquiredBeforeAttr>>(std::optional<mx::AcquiredBeforeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPMasterDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPMasterDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoMips16Attr>>(std::optional<mx::NoMips16Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelGenericLoopDirective>>(gap::generator<mx::OMPParallelGenericLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXMemberCallExpr>>(std::optional<mx::CXXMemberCallExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCAtSynchronizedStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCAtSynchronizedStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CallbackAttr>>(std::optional<mx::CallbackAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExportDecl>>(std::optional<mx::ExportDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AcquiredAfterAttr>>(gap::generator<mx::AcquiredAfterAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DIExpressionElemAttr>>(std::optional<mx::ir::llvm::DIExpressionElemAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoMicroMipsAttr>>(gap::generator<mx::NoMicroMipsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DbgLabelOp>>(std::optional<mx::ir::llvm::DbgLabelOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSAllocatorAttr>(mx::MSAllocatorAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DbgValueOp>(mx::ir::llvm::DbgValueOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CallableWhenAttr>>(gap::generator<mx::CallableWhenAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ExportDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ExportDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeclRefExpr>>(std::optional<mx::DeclRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DIExpressionAttr>(mx::ir::llvm::DIExpressionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AcquiredAfterAttr>>(std::optional<mx::AcquiredAfterAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DbgValueOp>>(std::optional<mx::ir::llvm::DbgValueOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoMicroMipsAttr>>(std::optional<mx::NoMicroMipsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DIExpressionAttr>>(std::optional<mx::ir::llvm::DIExpressionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MSABIAttr>(mx::MSABIAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeclOrStmtAttr>>(gap::generator<mx::DeclOrStmtAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CallableWhenAttr>>(std::optional<mx::CallableWhenAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelGenericLoopDirective>>(std::optional<mx::OMPParallelGenericLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AcquireHandleAttr>>(gap::generator<mx::AcquireHandleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DINullTypeAttr>(mx::ir::llvm::DINullTypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXX11NoReturnAttr>>(gap::generator<mx::CXX11NoReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelGenericLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelGenericLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAKernelCallExpr>>(gap::generator<mx::CUDAKernelCallExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DINullTypeAttr>>(std::optional<mx::ir::llvm::DINullTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MIGServerRoutineAttr>(mx::MIGServerRoutineAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DebugTrapOp>(mx::ir::llvm::DebugTrapOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoDuplicateAttr>>(gap::generator<mx::NoDuplicateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DIBasicTypeAttr>(mx::ir::llvm::DIBasicTypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AcquireHandleAttr>>(std::optional<mx::AcquireHandleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DebugTrapOp>>(std::optional<mx::ir::llvm::DebugTrapOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoInstrumentFunctionAttr>>(gap::generator<mx::NoInstrumentFunctionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DIBasicTypeAttr>>(std::optional<mx::ir::llvm::DIBasicTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAKernelCallExpr>>(std::optional<mx::CUDAKernelCallExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::EhTypeidForOp>(mx::ir::llvm::EhTypeidForOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::M68kRTDAttr>(mx::M68kRTDAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeclOrStmtAttr>>(std::optional<mx::DeclOrStmtAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXX11NoReturnAttr>>(std::optional<mx::CXX11NoReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::Exp2Op>(mx::ir::llvm::Exp2Op) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AVRSignalAttr>>(gap::generator<mx::AVRSignalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::EhTypeidForOp>>(std::optional<mx::ir::llvm::EhTypeidForOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoInstrumentFunctionAttr>>(std::optional<mx::NoInstrumentFunctionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DICompileUnitAttr>(mx::ir::llvm::DICompileUnitAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDASharedAttr>>(gap::generator<mx::CUDASharedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DICompileUnitAttr>>(std::optional<mx::ir::llvm::DICompileUnitAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IndirectGotoStmt>>(gap::generator<mx::IndirectGotoStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMaskedDirective>>(gap::generator<mx::OMPMaskedDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AcquireCapabilityAttr>>(gap::generator<mx::AcquireCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDispatchDirective>(mx::OMPDispatchDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::M68kInterruptAttr>(mx::M68kInterruptAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ExpOp>(mx::ir::llvm::ExpOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NullStmt>>(gap::generator<mx::NullStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPExecutableDirective>>(gap::generator<mx::OMPExecutableDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UserDefinedLiteral>>(gap::generator<mx::UserDefinedLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DICompositeTypeAttr>(mx::ir::llvm::DICompositeTypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AcquireCapabilityAttr>>(std::optional<mx::AcquireCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::Exp2Op>>(std::optional<mx::ir::llvm::Exp2Op>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoDuplicateAttr>>(std::optional<mx::NoDuplicateAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DICompositeTypeAttr>>(std::optional<mx::ir::llvm::DICompositeTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDASharedAttr>>(std::optional<mx::CUDASharedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlwaysInlineAttr>>(gap::generator<mx::AlwaysInlineAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoDestroyAttr>>(gap::generator<mx::NoDestroyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroSubstitution>>(gap::generator<mx::MacroSubstitution>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NullStmt>>(std::optional<mx::NullStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EmptyDecl>>(gap::generator<mx::EmptyDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LocksExcludedAttr>(mx::LocksExcludedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMaskedDirective>>(std::optional<mx::OMPMaskedDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDALaunchBoundsAttr>>(gap::generator<mx::CUDALaunchBoundsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPExecutableDirective>>(std::optional<mx::OMPExecutableDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UserDefinedLiteral>>(std::optional<mx::UserDefinedLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DIDerivedTypeAttr>(mx::ir::llvm::DIDerivedTypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AVRSignalAttr>>(std::optional<mx::AVRSignalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPMaskedDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPMaskedDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoDestroyAttr>>(std::optional<mx::NoDestroyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelForSimdDirective>>(gap::generator<mx::OMPParallelForSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LockReturnedAttr>(mx::LockReturnedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DIDerivedTypeAttr>>(std::optional<mx::ir::llvm::DIDerivedTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSDependentExistsStmt>>(gap::generator<mx::MSDependentExistsStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ExpOp>>(std::optional<mx::ir::llvm::ExpOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDALaunchBoundsAttr>>(std::optional<mx::CUDALaunchBoundsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPExecutableDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPExecutableDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AVRInterruptAttr>>(gap::generator<mx::AVRInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlwaysInlineAttr>>(std::optional<mx::AlwaysInlineAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoDebugAttr>>(gap::generator<mx::NoDebugAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EmptyDecl>>(std::optional<mx::EmptyDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXUuidofExpr>>(gap::generator<mx::CXXUuidofExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DIFileAttr>(mx::ir::llvm::DIFileAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAHostAttr>>(gap::generator<mx::CUDAHostAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::EmptyDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::EmptyDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSDependentExistsStmt>>(std::optional<mx::MSDependentExistsStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ExpectOp>(mx::ir::llvm::ExpectOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LifetimeBoundAttr>(mx::LifetimeBoundAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DIFileAttr>>(std::optional<mx::ir::llvm::DIFileAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinReferenceKind>>(std::optional<mx::BuiltinReferenceKind>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ExpectOp>>(std::optional<mx::ir::llvm::ExpectOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAInvalidTargetAttr>>(gap::generator<mx::CUDAInvalidTargetAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelForSimdDirective>>(std::optional<mx::OMPParallelForSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AVRInterruptAttr>>(std::optional<mx::AVRInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DIGlobalVariableExpressionAttr>(mx::ir::llvm::DIGlobalVariableExpressionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoDebugAttr>>(std::optional<mx::NoDebugAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelForSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelForSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXUuidofExpr>>(std::optional<mx::CXXUuidofExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DIGlobalVariableExpressionAttr>>(std::optional<mx::ir::llvm::DIGlobalVariableExpressionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LeafAttr>(mx::LeafAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FAbsOp>(mx::ir::llvm::FAbsOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAInvalidTargetAttr>>(std::optional<mx::CUDAInvalidTargetAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DIGlobalVariableAttr>(mx::ir::llvm::DIGlobalVariableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ARMInterruptAttr>>(gap::generator<mx::ARMInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ExpectWithProbabilityOp>(mx::ir::llvm::ExpectWithProbabilityOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoCommonAttr>>(gap::generator<mx::NoCommonAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ExpectWithProbabilityOp>>(std::optional<mx::ir::llvm::ExpectWithProbabilityOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LayoutVersionAttr>(mx::LayoutVersionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DIGlobalVariableAttr>>(std::optional<mx::ir::llvm::DIGlobalVariableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ARMInterruptAttr>>(std::optional<mx::ARMInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SuppressAttr>(mx::SuppressAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoCommonAttr>>(std::optional<mx::NoCommonAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SuppressAttr>>(gap::generator<mx::SuppressAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IndirectGotoStmt>>(std::optional<mx::IndirectGotoStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FCeilOp>(mx::ir::llvm::FCeilOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAHostAttr>>(std::optional<mx::CUDAHostAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DILexicalBlockAttr>(mx::ir::llvm::DILexicalBlockAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUWavesPerEUAttr>>(gap::generator<mx::AMDGPUWavesPerEUAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPLoopBasedDirective>>(gap::generator<mx::OMPLoopBasedDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoAliasAttr>>(gap::generator<mx::NoAliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DILexicalBlockAttr>>(std::optional<mx::ir::llvm::DILexicalBlockAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Type>>(std::optional<mx::Type>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FAbsOp>>(std::optional<mx::ir::llvm::FAbsOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LTOVisibilityPublicAttr>(mx::LTOVisibilityPublicAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CapturedStmt>(mx::CapturedStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAGlobalAttr>>(gap::generator<mx::CUDAGlobalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CapturedStmt>>(gap::generator<mx::CapturedStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXTypeidExpr>>(gap::generator<mx::CXXTypeidExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SuppressAttr>>(std::optional<mx::SuppressAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LabelDecl>>(gap::generator<mx::LabelDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DILexicalBlockFileAttr>(mx::ir::llvm::DILexicalBlockFileAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUWavesPerEUAttr>>(std::optional<mx::AMDGPUWavesPerEUAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DILexicalBlockFileAttr>>(std::optional<mx::ir::llvm::DILexicalBlockFileAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoAliasAttr>>(std::optional<mx::NoAliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FCeilOp>>(std::optional<mx::ir::llvm::FCeilOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InternalLinkageAttr>(mx::InternalLinkageAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPLoopBasedDirective>>(std::optional<mx::OMPLoopBasedDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXUnresolvedConstructExpr>>(gap::generator<mx::CXXUnresolvedConstructExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DILocalVariableAttr>(mx::ir::llvm::DILocalVariableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Designator>>(gap::generator<mx::Designator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPParallelForDirective>(mx::OMPParallelForDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAGlobalAttr>>(std::optional<mx::CUDAGlobalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CapturedStmt>>(std::optional<mx::CapturedStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUNumVGPRAttr>>(gap::generator<mx::AMDGPUNumVGPRAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPLoopBasedDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPLoopBasedDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NakedAttr>>(gap::generator<mx::NakedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPMasterTaskLoopDirective>(mx::OMPMasterTaskLoopDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXUnresolvedConstructExpr>>(std::optional<mx::CXXUnresolvedConstructExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DILocalVariableAttr>>(std::optional<mx::ir::llvm::DILocalVariableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LabelDecl>>(std::optional<mx::LabelDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelForDirective>>(gap::generator<mx::OMPParallelForDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IntelOclBiccAttr>(mx::IntelOclBiccAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CapturedStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::CapturedStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXCtorInitializer>>(gap::generator<mx::CXXCtorInitializer>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FMAOp>(mx::ir::llvm::FMAOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUNumVGPRAttr>>(std::optional<mx::AMDGPUNumVGPRAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FFloorOp>(mx::ir::llvm::FFloorOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NakedAttr>>(std::optional<mx::NakedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoMergeAttr>(mx::NoMergeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InitPriorityAttr>(mx::InitPriorityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FFloorOp>>(std::optional<mx::ir::llvm::FFloorOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDADeviceBuiltinTextureTypeAttr>>(gap::generator<mx::CUDADeviceBuiltinTextureTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DISubprogramAttr>(mx::ir::llvm::DISubprogramAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUNumSGPRAttr>>(gap::generator<mx::AMDGPUNumSGPRAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoMergeAttr>>(gap::generator<mx::NoMergeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NVPTXKernelAttr>>(gap::generator<mx::NVPTXKernelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DISubprogramAttr>>(std::optional<mx::ir::llvm::DISubprogramAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LabelStmt>>(gap::generator<mx::LabelStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelForDirective>>(std::optional<mx::OMPParallelForDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDADeviceBuiltinTextureTypeAttr>>(std::optional<mx::CUDADeviceBuiltinTextureTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroSubstitution>>(std::optional<mx::MacroSubstitution>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXTypeidExpr>>(std::optional<mx::CXXTypeidExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DIModuleAttr>(mx::ir::llvm::DIModuleAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDADeviceAttr>>(gap::generator<mx::CUDADeviceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPParallelForDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPParallelForDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InheritableParamAttr>(mx::InheritableParamAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DIModuleAttr>>(std::optional<mx::ir::llvm::DIModuleAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUNumSGPRAttr>>(std::optional<mx::AMDGPUNumSGPRAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FMAOp>>(std::optional<mx::ir::llvm::FMAOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NVPTXKernelAttr>>(std::optional<mx::NVPTXKernelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoMergeAttr>>(std::optional<mx::NoMergeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LabelStmt>>(std::optional<mx::LabelStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DINamespaceAttr>(mx::ir::llvm::DINamespaceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDADeviceBuiltinSurfaceTypeAttr>>(gap::generator<mx::CUDADeviceBuiltinSurfaceTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DINamespaceAttr>>(std::optional<mx::ir::llvm::DINamespaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VecTypeHintAttr>>(gap::generator<mx::VecTypeHintAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FMulAddOp>(mx::ir::llvm::FMulAddOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CarriesDependencyAttr>(mx::CarriesDependencyAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FMulAddOp>>(std::optional<mx::ir::llvm::FMulAddOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDADeviceBuiltinSurfaceTypeAttr>>(std::optional<mx::CUDADeviceBuiltinSurfaceTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPLoopTransformationDirective>(mx::OMPLoopTransformationDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUKernelCallAttr>>(gap::generator<mx::AMDGPUKernelCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPTileDirective>(mx::OMPTileDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSReturnsRetainedAttr>>(gap::generator<mx::NSReturnsRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroVAOpt>(mx::MacroVAOpt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSReturnsRetainedAttr>>(std::optional<mx::NSReturnsRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DISubrangeAttr>(mx::ir::llvm::DISubrangeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFConsumedAttr>(mx::CFConsumedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPLoopTransformationDirective>>(gap::generator<mx::OMPLoopTransformationDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDADeviceAttr>>(std::optional<mx::CUDADeviceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroVAOpt>>(gap::generator<mx::MacroVAOpt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUKernelCallAttr>>(std::optional<mx::AMDGPUKernelCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CapturedDecl>(mx::CapturedDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAConstantAttr>>(gap::generator<mx::CUDAConstantAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DISubrangeAttr>>(std::optional<mx::ir::llvm::DISubrangeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AMDGPUFlatWorkGroupSizeAttr>>(gap::generator<mx::AMDGPUFlatWorkGroupSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CapturedDecl>>(gap::generator<mx::CapturedDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnnotateAttr>(mx::AnnotateAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoInlineAttr>(mx::NoInlineAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXThrowExpr>>(gap::generator<mx::CXXThrowExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DLLImportAttr>(mx::DLLImportAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IfStmt>>(gap::generator<mx::IfStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DISubroutineTypeAttr>(mx::ir::llvm::DISubroutineTypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AMDGPUFlatWorkGroupSizeAttr>>(std::optional<mx::AMDGPUFlatWorkGroupSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoInlineAttr>>(gap::generator<mx::NoInlineAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSReturnsNotRetainedAttr>>(gap::generator<mx::NSReturnsNotRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FShlOp>(mx::ir::llvm::FShlOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IfStmt>>(std::optional<mx::IfStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FTruncOp>(mx::ir::llvm::FTruncOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXThrowExpr>>(std::optional<mx::CXXThrowExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DISubroutineTypeAttr>>(std::optional<mx::ir::llvm::DISubroutineTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UseHandleAttr>(mx::UseHandleAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FTruncOp>>(std::optional<mx::ir::llvm::FTruncOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAConstantAttr>>(std::optional<mx::CUDAConstantAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPLoopTransformationDirective>>(std::optional<mx::OMPLoopTransformationDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AArch64SVEPcsAttr>>(gap::generator<mx::AArch64SVEPcsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::DILabelAttr>(mx::ir::llvm::DILabelAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSReturnsNotRetainedAttr>>(std::optional<mx::NSReturnsNotRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::DILabelAttr>>(std::optional<mx::ir::llvm::DILabelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CPUSpecificAttr>>(gap::generator<mx::CPUSpecificAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPLoopTransformationDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPLoopTransformationDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSErrorDomainAttr>>(gap::generator<mx::NSErrorDomainAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CapturedDecl>>(std::optional<mx::CapturedDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AArch64VectorPcsAttr>>(gap::generator<mx::AArch64VectorPcsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPMasterTaskLoopSimdDirective>(mx::OMPMasterTaskLoopSimdDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReleaseHandleAttr>(mx::ReleaseHandleAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPMaskedTaskLoopSimdDirective>(mx::OMPMaskedTaskLoopSimdDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeclStmt>>(gap::generator<mx::DeclStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FShrOp>(mx::ir::llvm::FShrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSReturnsAutoreleasedAttr>>(gap::generator<mx::NSReturnsAutoreleasedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMasterTaskLoopSimdDirective>>(gap::generator<mx::OMPMasterTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CPUSpecificAttr>>(std::optional<mx::CPUSpecificAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroVAOpt>>(std::optional<mx::MacroVAOpt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AArch64VectorPcsAttr>>(std::optional<mx::AArch64VectorPcsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoInlineAttr>>(std::optional<mx::NoInlineAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSReturnsAutoreleasedAttr>>(std::optional<mx::NSReturnsAutoreleasedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CapturedDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::CapturedDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PassObjectSizeAttr>(mx::PassObjectSizeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MemoryEffectsAttr>(mx::ir::llvm::MemoryEffectsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CPUDispatchAttr>>(gap::generator<mx::CPUDispatchAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FShlOp>>(std::optional<mx::ir::llvm::FShlOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeclStmt>>(std::optional<mx::DeclStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MemoryEffectsAttr>>(std::optional<mx::ir::llvm::MemoryEffectsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXThisExpr>>(gap::generator<mx::CXXThisExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AliasScopeDomainAttr>(mx::ir::llvm::AliasScopeDomainAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AArch64SVEPcsAttr>>(std::optional<mx::AArch64SVEPcsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMasterTaskLoopSimdDirective>>(std::optional<mx::OMPMasterTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSErrorDomainAttr>>(std::optional<mx::NSErrorDomainAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AliasScopeDomainAttr>>(std::optional<mx::ir::llvm::AliasScopeDomainAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParameterABIAttr>(mx::ParameterABIAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AliasScopeAttr>(mx::ir::llvm::AliasScopeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXThisExpr>>(std::optional<mx::CXXThisExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FShrOp>>(std::optional<mx::ir::llvm::FShrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CPUDispatchAttr>>(std::optional<mx::CPUDispatchAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPMasterTaskLoopSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPMasterTaskLoopSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::XRayLogArgsAttr>>(gap::generator<mx::XRayLogArgsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DLLImportStaticLocalAttr>(mx::DLLImportStaticLocalAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSConsumesSelfAttr>>(gap::generator<mx::NSConsumesSelfAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DLLExportStaticLocalAttr>(mx::DLLExportStaticLocalAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftIndirectResultAttr>(mx::SwiftIndirectResultAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EmptyTokenTreeNode>>(std::optional<mx::EmptyTokenTreeNode>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ZeroCallUsedRegsAttr>>(gap::generator<mx::ZeroCallUsedRegsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DLLImportStaticLocalAttr>>(gap::generator<mx::DLLImportStaticLocalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFUnknownTransferAttr>>(gap::generator<mx::CFUnknownTransferAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AliasScopeAttr>>(std::optional<mx::ir::llvm::AliasScopeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSConsumesSelfAttr>>(std::optional<mx::NSConsumesSelfAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TokenTokenTreeNode>(mx::TokenTokenTreeNode) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftErrorResultAttr>(mx::SwiftErrorResultAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AccessGroupAttr>(mx::ir::llvm::AccessGroupAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFUnknownTransferAttr>>(std::optional<mx::CFUnknownTransferAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TokenTokenTreeNode>>(std::optional<mx::TokenTokenTreeNode>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ZeroCallUsedRegsAttr>>(std::optional<mx::ZeroCallUsedRegsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::GetActiveLaneMaskOp>(mx::ir::llvm::GetActiveLaneMaskOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MipsShortCallAttr>>(gap::generator<mx::MipsShortCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AccessGroupAttr>>(std::optional<mx::ir::llvm::AccessGroupAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXStdInitializerListExpr>>(gap::generator<mx::CXXStdInitializerListExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::GetActiveLaneMaskOp>>(std::optional<mx::ir::llvm::GetActiveLaneMaskOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFReturnsRetainedAttr>>(gap::generator<mx::CFReturnsRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ChoiceTokenTreeNode>(mx::ChoiceTokenTreeNode) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftContextAttr>(mx::SwiftContextAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::TBAARootAttr>(mx::ir::llvm::TBAARootAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GotoStmt>>(gap::generator<mx::GotoStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ChoiceTokenTreeNode>>(std::optional<mx::ChoiceTokenTreeNode>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXStdInitializerListExpr>>(std::optional<mx::CXXStdInitializerListExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPUnrollDirective>(mx::OMPUnrollDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::XRayLogArgsAttr>>(std::optional<mx::XRayLogArgsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPLoopDirective>(mx::OMPLoopDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MipsShortCallAttr>>(std::optional<mx::MipsShortCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DLLImportStaticLocalAttr>>(std::optional<mx::DLLImportStaticLocalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFReturnsRetainedAttr>>(std::optional<mx::CFReturnsRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPUnrollDirective>>(gap::generator<mx::OMPUnrollDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::XRayInstrumentAttr>>(gap::generator<mx::XRayInstrumentAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SubstitutionTokenTreeNode>(mx::SubstitutionTokenTreeNode) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MipsLongCallAttr>>(gap::generator<mx::MipsLongCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::TBAARootAttr>>(std::optional<mx::ir::llvm::TBAARootAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncContextAttr>(mx::SwiftAsyncContextAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::Fragment, mx::TokenTreeNode>>>(gap::generator<std::pair<mx::Fragment, mx::TokenTreeNode>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GotoStmt>>(std::optional<mx::GotoStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::TBAAMemberAttr>(mx::ir::llvm::TBAAMemberAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXScalarValueInitExpr>>(gap::generator<mx::CXXScalarValueInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::InvariantStartOp>(mx::ir::llvm::InvariantStartOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::XRayInstrumentAttr>>(std::optional<mx::XRayInstrumentAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SequenceTokenTreeNode>(mx::SequenceTokenTreeNode) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MipsLongCallAttr>>(std::optional<mx::MipsLongCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::InvariantEndOp>(mx::ir::llvm::InvariantEndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OSConsumedAttr>(mx::OSConsumedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstitutionTokenTreeNode>>(std::optional<mx::SubstitutionTokenTreeNode>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ForStmt>>(gap::generator<mx::ForStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::TBAATagAttr>(mx::ir::llvm::TBAATagAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXScalarValueInitExpr>>(std::optional<mx::CXXScalarValueInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::InvariantEndOp>>(std::optional<mx::ir::llvm::InvariantEndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFReturnsNotRetainedAttr>>(gap::generator<mx::CFReturnsNotRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::variant<mx::MacroSubstitution, mx::MacroVAOpt>>(std::variant<mx::MacroSubstitution, mx::MacroVAOpt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MipsInterruptAttr>>(gap::generator<mx::MipsInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::TBAAMemberAttr>>(std::optional<mx::ir::llvm::TBAAMemberAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFReturnsNotRetainedAttr>>(std::optional<mx::CFReturnsNotRetainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPUnrollDirective>>(std::optional<mx::OMPUnrollDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NonNullAttr>(mx::NonNullAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::TBAATypeDescriptorAttr>(mx::ir::llvm::TBAATypeDescriptorAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFGuardAttr>>(gap::generator<mx::CFGuardAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::IsConstantOp>(mx::ir::llvm::IsConstantOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ForStmt>>(std::optional<mx::ForStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RenderScriptKernelAttr>>(std::optional<mx::RenderScriptKernelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::X86ForceAlignArgPointerAttr>>(gap::generator<mx::X86ForceAlignArgPointerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RegCallAttr>>(std::optional<mx::RegCallAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MipsInterruptAttr>>(std::optional<mx::MipsInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::BinLOrOp>>(std::optional<mx::ir::core::BinLOrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXNoexceptExpr>>(gap::generator<mx::CXXNoexceptExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AvailableOnlyInDefaultEvalMethodAttr>>(gap::generator<mx::AvailableOnlyInDefaultEvalMethodAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NSConsumedAttr>(mx::NSConsumedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AddrLabelExprOp>>(std::optional<mx::ir::hl::AddrLabelExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFICanonicalJumpTableAttr>>(gap::generator<mx::CFICanonicalJumpTableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::LazyOp>(mx::ir::core::LazyOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::X86ForceAlignArgPointerAttr>>(std::optional<mx::X86ForceAlignArgPointerAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AddressOfOp>(mx::ir::hl::AddressOfOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Mips16Attr>>(gap::generator<mx::Mips16Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::ImplicitReturnOp>(mx::ir::core::ImplicitReturnOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFICanonicalJumpTableAttr>>(std::optional<mx::CFICanonicalJumpTableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OverloadableAttr>>(gap::generator<mx::OverloadableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WorkGroupSizeHintAttr>>(gap::generator<mx::WorkGroupSizeHintAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::ImplicitReturnOp>>(std::optional<mx::ir::core::ImplicitReturnOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DoStmt>>(gap::generator<mx::DoStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AddressOfOp>>(std::optional<mx::ir::hl::AddressOfOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXRewrittenBinaryOperator>>(gap::generator<mx::CXXRewrittenBinaryOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AvailableOnlyInDefaultEvalMethodAttr>>(std::optional<mx::AvailableOnlyInDefaultEvalMethodAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXRewrittenBinaryOperator>>(std::optional<mx::CXXRewrittenBinaryOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReadOnlyPlacementAttr>>(gap::generator<mx::ReadOnlyPlacementAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IFuncAttr>(mx::IFuncAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AlignOfExprOp>(mx::ir::hl::AlignOfExprOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WorkGroupSizeHintAttr>>(std::optional<mx::WorkGroupSizeHintAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::LazyOp>>(std::optional<mx::ir::core::LazyOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Mips16Attr>>(std::optional<mx::Mips16Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IndirectFieldDecl>(mx::IndirectFieldDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DoStmt>>(std::optional<mx::DoStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AlignOfExprOp>>(std::optional<mx::ir::hl::AlignOfExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFGuardAttr>>(std::optional<mx::CFGuardAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IndirectFieldDecl>>(std::optional<mx::IndirectFieldDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MinVectorWidthAttr>>(gap::generator<mx::MinVectorWidthAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OverloadableAttr>>(std::optional<mx::OverloadableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CalledOnceAttr>(mx::CalledOnceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GNUNullExpr>>(gap::generator<mx::GNUNullExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CDeclAttr>>(gap::generator<mx::CDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IndirectFieldDecl>>(gap::generator<mx::IndirectFieldDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXPseudoDestructorExpr>>(gap::generator<mx::CXXPseudoDestructorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::variant<mx::NamedDecl, mx::DefineMacroDirective, mx::File>>>(gap::generator<std::variant<mx::NamedDecl, mx::DefineMacroDirective, mx::File>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroutineBodyStmt>>(gap::generator<mx::CoroutineBodyStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReadOnlyPlacementAttr>>(std::optional<mx::ReadOnlyPlacementAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFAuditedTransferAttr>>(gap::generator<mx::CFAuditedTransferAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::ScopeOp>(mx::ir::core::ScopeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WebAssemblyImportNameAttr>>(gap::generator<mx::WebAssemblyImportNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AvailabilityAttr>>(gap::generator<mx::AvailabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MinVectorWidthAttr>>(std::optional<mx::MinVectorWidthAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AsmOp>(mx::ir::hl::AsmOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BuiltinAliasAttr>(mx::BuiltinAliasAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AlignOfTypeOp>(mx::ir::hl::AlignOfTypeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXPseudoDestructorExpr>>(std::optional<mx::CXXPseudoDestructorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::ModuleOp>(mx::ir::core::ModuleOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CFAuditedTransferAttr>>(std::optional<mx::CFAuditedTransferAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::ModuleOp>>(std::optional<mx::ir::core::ModuleOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WebAssemblyImportNameAttr>>(std::optional<mx::WebAssemblyImportNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AlignOfTypeOp>>(std::optional<mx::ir::hl::AlignOfTypeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MinSizeAttr>>(gap::generator<mx::MinSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GNUNullExpr>>(std::optional<mx::GNUNullExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroutineBodyStmt>>(std::optional<mx::CoroutineBodyStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::GNUNullExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::GNUNullExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateTypeParmType>(mx::TemplateTypeParmType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLAccessAttr>>(gap::generator<mx::OpenCLAccessAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXParenListInitExpr>>(gap::generator<mx::CXXParenListInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::IndirectFieldDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::IndirectFieldDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WebAssemblyImportModuleAttr>>(gap::generator<mx::WebAssemblyImportModuleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AvailabilityAttr>>(std::optional<mx::AvailabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MinSizeAttr>>(std::optional<mx::MinSizeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RandomizeLayoutAttr>>(gap::generator<mx::RandomizeLayoutAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateTypeParmDecl>(mx::TemplateTypeParmDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AsmOp>>(std::optional<mx::ir::hl::AsmOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CDeclAttr>>(std::optional<mx::CDeclAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::ScopeOp>>(std::optional<mx::ir::core::ScopeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WebAssemblyImportModuleAttr>>(std::optional<mx::WebAssemblyImportModuleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::Stmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::Stmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MicroMipsAttr>>(gap::generator<mx::MicroMipsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLAccessAttr>>(std::optional<mx::OpenCLAccessAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::C11NoReturnAttr>>(gap::generator<mx::C11NoReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::core::SelectOp>(mx::ir::core::SelectOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WeakRefAttr>>(gap::generator<mx::WeakRefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AssignOp>(mx::ir::hl::AssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXParenListInitExpr>>(std::optional<mx::CXXParenListInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::core::SelectOp>>(std::optional<mx::ir::core::SelectOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateSpecializationType>(mx::TemplateSpecializationType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AssignOp>>(std::optional<mx::ir::hl::AssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WebAssemblyExportNameAttr>>(gap::generator<mx::WebAssemblyExportNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RandomizeLayoutAttr>>(std::optional<mx::RandomizeLayoutAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MicroMipsAttr>>(std::optional<mx::MicroMipsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AssumptionAttr>(mx::AssumptionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::C11NoReturnAttr>>(std::optional<mx::C11NoReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssumptionAttr>>(gap::generator<mx::AssumptionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WebAssemblyExportNameAttr>>(std::optional<mx::WebAssemblyExportNameAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::meta::Attribute>(mx::ir::meta::Attribute) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MaybeUndefAttr>>(gap::generator<mx::MaybeUndefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::AttributedStmtOp>(mx::ir::hl::AttributedStmtOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TagType>(mx::TagType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::meta::Attribute>>(std::optional<mx::ir::meta::Attribute>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinAttr>>(gap::generator<mx::BuiltinAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::AttributedStmtOp>>(std::optional<mx::ir::hl::AttributedStmtOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WeakRefAttr>>(std::optional<mx::WeakRefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRuntimeVisibleAttr>(mx::ObjCRuntimeVisibleAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MaybeUndefAttr>>(std::optional<mx::MaybeUndefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::unsup::Type>(mx::ir::unsup::Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RecordType>(mx::RecordType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::meta::IdentifierAttr>(mx::ir::meta::IdentifierAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXNullPtrLiteralExpr>>(gap::generator<mx::CXXNullPtrLiteralExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRuntimeVisibleAttr>>(gap::generator<mx::ObjCRuntimeVisibleAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinAttr>>(std::optional<mx::BuiltinAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RISCVInterruptAttr>(mx::RISCVInterruptAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WeakImportAttr>>(gap::generator<mx::WeakImportAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionParmPackExpr>>(gap::generator<mx::FunctionParmPackExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MayAliasAttr>>(gap::generator<mx::MayAliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RISCVInterruptAttr>>(gap::generator<mx::RISCVInterruptAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXNullPtrLiteralExpr>>(std::optional<mx::CXXNullPtrLiteralExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::meta::IdentifierAttr>>(std::optional<mx::ir::meta::IdentifierAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BlocksAttr>>(gap::generator<mx::BlocksAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinAShrAssignOp>(mx::ir::hl::BinAShrAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EnumType>(mx::EnumType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinAShrAssignOp>>(std::optional<mx::ir::hl::BinAShrAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WeakImportAttr>>(std::optional<mx::WeakImportAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssumptionAttr>>(std::optional<mx::AssumptionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MayAliasAttr>>(std::optional<mx::MayAliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::unsup::Type>>(std::optional<mx::ir::unsup::Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoreturnStmt>>(gap::generator<mx::CoreturnStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RecordDecl>(mx::RecordDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SubstTemplateTypeParmType>(mx::SubstTemplateTypeParmType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXRecordDecl>>(gap::generator<mx::CXXRecordDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BlocksAttr>>(std::optional<mx::BlocksAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::unsup::UnsupportedType>(mx::ir::unsup::UnsupportedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WeakAttr>>(gap::generator<mx::WeakAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionParmPackExpr>>(std::optional<mx::FunctionParmPackExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSVtorDispAttr>>(gap::generator<mx::MSVtorDispAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRuntimeVisibleAttr>>(std::optional<mx::ObjCRuntimeVisibleAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BTFDeclTagAttr>>(gap::generator<mx::BTFDeclTagAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RISCVInterruptAttr>>(std::optional<mx::RISCVInterruptAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoreturnStmt>>(std::optional<mx::CoreturnStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TagDecl>(mx::TagDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MaxFieldAlignmentAttr>>(gap::generator<mx::MaxFieldAlignmentAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RecordDecl>>(gap::generator<mx::RecordDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SubstTemplateTypeParmPackType>(mx::SubstTemplateTypeParmPackType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinAShrOp>(mx::ir::hl::BinAShrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXNoexceptExpr>>(std::optional<mx::CXXNoexceptExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::unsup::UnsupportedType>>(std::optional<mx::ir::unsup::UnsupportedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WeakAttr>>(std::optional<mx::WeakAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeDecl>(mx::TypeDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MaxFieldAlignmentAttr>>(std::optional<mx::MaxFieldAlignmentAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FunctionParmPackExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::FunctionParmPackExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BTFDeclTagAttr>>(std::optional<mx::BTFDeclTagAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinAShrOp>>(std::optional<mx::ir::hl::BinAShrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WarnUnusedAttr>>(gap::generator<mx::WarnUnusedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeDecl>>(gap::generator<mx::TypeDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXTryStmt>>(gap::generator<mx::CXXTryStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::unsup::Operation>(mx::ir::unsup::Operation) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReferenceType>(mx::ReferenceType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::unsup::Operation>>(std::optional<mx::ir::unsup::Operation>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXNewExpr>>(gap::generator<mx::CXXNewExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AssumeAlignedAttr>(mx::AssumeAlignedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WarnUnusedResultAttr>>(gap::generator<mx::WarnUnusedResultAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssumeAlignedAttr>>(gap::generator<mx::AssumeAlignedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ContinueStmt>>(gap::generator<mx::ContinueStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::unsup::UnsupportedDeclOp>(mx::ir::unsup::UnsupportedDeclOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSVtorDispAttr>>(std::optional<mx::MSVtorDispAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::unsup::UnsupportedDeclOp>>(std::optional<mx::ir::unsup::UnsupportedDeclOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RValueReferenceType>(mx::RValueReferenceType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinAndAssignOp>(mx::ir::hl::BinAndAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BPFPreserveStaticOffsetAttr>>(gap::generator<mx::BPFPreserveStaticOffsetAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCRuntimeNameAttr>(mx::ObjCRuntimeNameAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WarnUnusedResultAttr>>(std::optional<mx::WarnUnusedResultAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinAndAssignOp>>(std::optional<mx::ir::hl::BinAndAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSStructAttr>>(gap::generator<mx::MSStructAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCRuntimeNameAttr>>(gap::generator<mx::ObjCRuntimeNameAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ContinueStmt>>(std::optional<mx::ContinueStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeDecl>>(std::optional<mx::TypeDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXNewExpr>>(std::optional<mx::CXXNewExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PureAttr>(mx::PureAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BPFPreserveStaticOffsetAttr>>(std::optional<mx::BPFPreserveStaticOffsetAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PureAttr>>(gap::generator<mx::PureAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::LValueReferenceType>(mx::LValueReferenceType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TypeDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TypeDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WarnUnusedAttr>>(std::optional<mx::WarnUnusedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::unsup::UnsupportedStmtOp>(mx::ir::unsup::UnsupportedStmtOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSStructAttr>>(std::optional<mx::MSStructAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssumeAlignedAttr>>(std::optional<mx::AssumeAlignedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::QualifiedType>(mx::QualifiedType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::unsup::UnsupportedStmtOp>>(std::optional<mx::ir::unsup::UnsupportedStmtOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BPFPreserveAccessIndexAttr>>(gap::generator<mx::BPFPreserveAccessIndexAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinAndOp>(mx::ir::hl::BinAndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VisibilityAttr>>(gap::generator<mx::VisibilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinAndOp>>(std::optional<mx::ir::hl::BinAndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSP430InterruptAttr>>(gap::generator<mx::MSP430InterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCRuntimeNameAttr>>(std::optional<mx::ObjCRuntimeNameAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BPFPreserveAccessIndexAttr>>(std::optional<mx::BPFPreserveAccessIndexAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PureAttr>>(std::optional<mx::PureAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXTryStmt>>(std::optional<mx::CXXTryStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::Decl, mx::ir::Operation>>>(gap::generator<std::pair<mx::Decl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCPropertyRefExpr>>(std::optional<mx::ObjCPropertyRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FullExpr>(mx::FullExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AvailableOnlyInDefaultEvalMethodAttr>>(gap::generator<mx::AvailableOnlyInDefaultEvalMethodAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstantExpr>(mx::ConstantExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PointerType>(mx::PointerType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FullExpr>>(gap::generator<mx::FullExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXConstructExpr>>(gap::generator<mx::CXXConstructExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinCommaOp>(mx::ir::hl::BinCommaOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VisibilityAttr>>(std::optional<mx::VisibilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinCommaOp>>(std::optional<mx::ir::hl::BinCommaOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSP430InterruptAttr>>(std::optional<mx::MSP430InterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AssertSharedLockAttr>(mx::AssertSharedLockAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AvailableOnlyInDefaultEvalMethodAttr>>(std::optional<mx::AvailableOnlyInDefaultEvalMethodAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AssertCapabilityAttr>(mx::AssertCapabilityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VectorCallAttr>>(gap::generator<mx::VectorCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssertSharedLockAttr>>(gap::generator<mx::AssertSharedLockAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSNoVTableAttr>>(gap::generator<mx::MSNoVTableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCNonRuntimeProtocolAttr>(mx::ObjCNonRuntimeProtocolAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PipeType>(mx::PipeType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCDirectMembersAttr>(mx::ObjCDirectMembersAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXCatchStmt>>(gap::generator<mx::CXXCatchStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PtGuardedVarAttr>(mx::PtGuardedVarAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AvailabilityAttr>>(gap::generator<mx::AvailabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCNonRuntimeProtocolAttr>>(gap::generator<mx::ObjCNonRuntimeProtocolAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXConstructExpr>>(std::optional<mx::CXXConstructExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PreserveMostAttr>(mx::PreserveMostAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIvarDecl>>(gap::generator<mx::ObjCIvarDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PtGuardedVarAttr>>(gap::generator<mx::PtGuardedVarAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCContainerDecl>>(std::optional<mx::ObjCContainerDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FullExpr>>(std::optional<mx::FullExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VectorCallAttr>>(std::optional<mx::VectorCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinLAndOp>(mx::ir::hl::BinLAndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSNoVTableAttr>>(std::optional<mx::MSNoVTableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TagDecl>>(gap::generator<mx::TagDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParenType>(mx::ParenType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinLAndOp>>(std::optional<mx::ir::hl::BinLAndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXCatchStmt>>(std::optional<mx::CXXCatchStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FullExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::FullExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AvailabilityAttr>>(std::optional<mx::AvailabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssertSharedLockAttr>>(std::optional<mx::AssertSharedLockAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSInheritanceAttr>>(gap::generator<mx::MSInheritanceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCNonRuntimeProtocolAttr>>(std::optional<mx::ObjCNonRuntimeProtocolAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssumptionAttr>>(gap::generator<mx::AssumptionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PtGuardedVarAttr>>(std::optional<mx::PtGuardedVarAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PackExpansionType>(mx::PackExpansionType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TagDecl>>(std::optional<mx::TagDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VecTypeHintAttr>>(std::optional<mx::VecTypeHintAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinLOrOp>(mx::ir::hl::BinLOrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UuidAttr>>(gap::generator<mx::UuidAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinLOrOp>>(std::optional<mx::ir::hl::BinLOrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSInheritanceAttr>>(std::optional<mx::MSInheritanceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TagDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TagDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCMethodDecl>>(std::optional<mx::ObjCMethodDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExternalSourceSymbolAttr>(mx::ExternalSourceSymbolAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCTypeParamType>(mx::ObjCTypeParamType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AssertExclusiveLockAttr>(mx::AssertExclusiveLockAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssumptionAttr>>(std::optional<mx::AssumptionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AsmLabelAttr>(mx::AsmLabelAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSConstexprAttr>>(gap::generator<mx::MSConstexprAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssertExclusiveLockAttr>>(gap::generator<mx::AssertExclusiveLockAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXForRangeStmt>>(gap::generator<mx::CXXForRangeStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExternalSourceSymbolAttr>>(std::optional<mx::ExternalSourceSymbolAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VecReturnAttr>>(gap::generator<mx::VecReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InheritableAttr>(mx::InheritableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXForRangeStmt>>(std::optional<mx::CXXForRangeStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExternalSourceSymbolAttr>>(gap::generator<mx::ExternalSourceSymbolAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCObjectType>(mx::ObjCObjectType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCNonLazyClassAttr>(mx::ObjCNonLazyClassAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssumeAlignedAttr>>(std::optional<mx::AssumeAlignedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCDirectAttr>(mx::ObjCDirectAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VecReturnAttr>>(std::optional<mx::VecReturnAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InheritableAttr>>(gap::generator<mx::InheritableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSConstexprAttr>>(std::optional<mx::MSConstexprAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PtGuardedByAttr>(mx::PtGuardedByAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlignedAttr>>(gap::generator<mx::AlignedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCNonLazyClassAttr>>(gap::generator<mx::ObjCNonLazyClassAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSAllocatorAttr>>(gap::generator<mx::MSAllocatorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PreserveAllAttr>(mx::PreserveAllAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCPropertyDecl>>(std::optional<mx::ObjCPropertyDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PtGuardedByAttr>>(gap::generator<mx::PtGuardedByAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCTypeParamDecl>(mx::ObjCTypeParamDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinLShrAssignOp>(mx::ir::hl::BinLShrAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AsmStmt>>(gap::generator<mx::AsmStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinLShrAssignOp>>(std::optional<mx::ir::hl::BinLShrAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AsmLabelAttr>>(gap::generator<mx::AsmLabelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssertExclusiveLockAttr>>(std::optional<mx::AssertExclusiveLockAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UuidAttr>>(std::optional<mx::UuidAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExprWithCleanups>(mx::ExprWithCleanups) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXFoldExpr>>(gap::generator<mx::CXXFoldExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FloatingLiteral>(mx::FloatingLiteral) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssertSharedLockAttr>>(gap::generator<mx::AssertSharedLockAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExprWithCleanups>>(gap::generator<mx::ExprWithCleanups>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSAllocatorAttr>>(std::optional<mx::MSAllocatorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InheritableAttr>>(std::optional<mx::InheritableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCInterfaceType>(mx::ObjCInterfaceType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinOrAssignOp>(mx::ir::hl::BinOrAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BreakStmt>>(gap::generator<mx::BreakStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinLShrOp>(mx::ir::hl::BinLShrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXInheritedCtorInitExpr>>(gap::generator<mx::CXXInheritedCtorInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCNonLazyClassAttr>>(std::optional<mx::ObjCNonLazyClassAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSABIAttr>>(gap::generator<mx::MSABIAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PtGuardedByAttr>>(std::optional<mx::PtGuardedByAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXInheritedCtorInitExpr>>(std::optional<mx::CXXInheritedCtorInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinLShrOp>>(std::optional<mx::ir::hl::BinLShrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSGuidDecl>>(gap::generator<mx::MSGuidDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPErrorDirective>>(gap::generator<mx::OMPErrorDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssertSharedLockAttr>>(std::optional<mx::AssertSharedLockAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoThrowAttr>>(gap::generator<mx::NoThrowAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BreakStmt>>(std::optional<mx::BreakStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CompoundAssignOperator>>(std::optional<mx::CompoundAssignOperator>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCObjectPointerType>(mx::ObjCObjectPointerType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSGuidDecl>(mx::MSGuidDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssertExclusiveLockAttr>>(gap::generator<mx::AssertExclusiveLockAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPErrorDirective>>(std::optional<mx::OMPErrorDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSGuidDecl>>(std::optional<mx::MSGuidDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSGuidDecl>>(gap::generator<mx::MSGuidDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSABIAttr>>(std::optional<mx::MSABIAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CompoundAssignOperator, mx::ir::Operation>>>(gap::generator<std::pair<mx::CompoundAssignOperator, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MemberPointerType>(mx::MemberPointerType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCapturedExprDecl>>(gap::generator<mx::OMPCapturedExprDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssertExclusiveLockAttr>>(std::optional<mx::AssertExclusiveLockAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPErrorDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPErrorDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::M68kRTDAttr>>(gap::generator<mx::M68kRTDAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoThrowAttr>>(std::optional<mx::NoThrowAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIvarDecl>>(std::optional<mx::ObjCIvarDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSGuidDecl>>(std::optional<mx::MSGuidDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssertCapabilityAttr>>(gap::generator<mx::AssertCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCapturedExprDecl>>(std::optional<mx::OMPCapturedExprDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MIGServerRoutineAttr>>(gap::generator<mx::MIGServerRoutineAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::MSGuidDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::MSGuidDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MatrixType>(mx::MatrixType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPCapturedExprDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPCapturedExprDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AsmStmt>>(std::optional<mx::AsmStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoThreadSafetyAnalysisAttr>>(gap::generator<mx::NoThreadSafetyAnalysisAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingIfExistsAttr>>(gap::generator<mx::UsingIfExistsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AtomicExpr>>(gap::generator<mx::AtomicExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXFoldExpr>>(std::optional<mx::CXXFoldExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoThreadSafetyAnalysisAttr>>(std::optional<mx::NoThreadSafetyAnalysisAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssertCapabilityAttr>>(std::optional<mx::AssertCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDispatchDirective>>(gap::generator<mx::OMPDispatchDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MIGServerRoutineAttr>>(std::optional<mx::MIGServerRoutineAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<uint64_t>(uint64_t) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentSizedMatrixType>(mx::DependentSizedMatrixType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<uint32_t>(uint32_t) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingIfExistsAttr>>(std::optional<mx::UsingIfExistsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<int64_t>(int64_t) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsedAttr>>(gap::generator<mx::UsedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<int32_t>(int32_t) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AsmLabelAttr>>(std::optional<mx::AsmLabelAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<bool>(bool) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::M68kRTDAttr>>(std::optional<mx::M68kRTDAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<double>(double) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstantMatrixType>(mx::ConstantMatrixType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AtomicExpr>>(std::optional<mx::AtomicExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArtificialAttr>>(gap::generator<mx::ArtificialAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDispatchDirective>>(std::optional<mx::OMPDispatchDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::M68kInterruptAttr>>(gap::generator<mx::M68kInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoStackProtectorAttr>(mx::NoStackProtectorAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSAsmStmt>>(gap::generator<mx::MSAsmStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::AtomicExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::AtomicExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDeleteExpr>>(gap::generator<mx::CXXDeleteExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DecompositionDecl>(mx::DecompositionDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsedAttr>>(std::optional<mx::UsedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsingIfExistsAttr>>(gap::generator<mx::UsingIfExistsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDependentScopeMemberExpr>>(gap::generator<mx::CXXDependentScopeMemberExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VarTemplatePartialSpecializationDecl>(mx::VarTemplatePartialSpecializationDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroQualifiedType>(mx::MacroQualifiedType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoStackProtectorAttr>>(gap::generator<mx::NoStackProtectorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnusedAttr>>(gap::generator<mx::UnusedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DecompositionDecl>>(gap::generator<mx::DecompositionDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSAsmStmt>>(std::optional<mx::MSAsmStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDispatchDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDispatchDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDependentScopeMemberExpr>>(std::optional<mx::CXXDependentScopeMemberExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsingIfExistsAttr>>(std::optional<mx::UsingIfExistsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArtificialAttr>>(std::optional<mx::ArtificialAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DecompositionDecl>>(std::optional<mx::DecompositionDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::M68kInterruptAttr>>(std::optional<mx::M68kInterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoStackProtectorAttr>>(std::optional<mx::NoStackProtectorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ComplexType>(mx::ComplexType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DecompositionDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::DecompositionDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmNewAttr>>(gap::generator<mx::ArmNewAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UsedAttr>>(gap::generator<mx::UsedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LocksExcludedAttr>>(gap::generator<mx::LocksExcludedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoSplitStackAttr>(mx::NoSplitStackAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnusedAttr>>(std::optional<mx::UnusedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoSplitStackAttr>>(gap::generator<mx::NoSplitStackAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GCCAsmStmt>>(gap::generator<mx::GCCAsmStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDepobjDirective>(mx::OMPDepobjDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImplicitParamDecl>>(std::optional<mx::ImplicitParamDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPCancellationPointDirective>(mx::OMPCancellationPointDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UninitializedAttr>>(gap::generator<mx::UninitializedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDepobjDirective>>(gap::generator<mx::OMPDepobjDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InjectedClassNameType>(mx::InjectedClassNameType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UsedAttr>>(std::optional<mx::UsedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmNewAttr>>(std::optional<mx::ArmNewAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoSplitStackAttr>>(std::optional<mx::NoSplitStackAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LocksExcludedAttr>>(std::optional<mx::LocksExcludedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDepobjDirective>>(std::optional<mx::OMPDepobjDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmBuiltinAliasAttr>>(gap::generator<mx::ArmBuiltinAliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArraySubscriptExpr>(mx::ArraySubscriptExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnsafeBufferUsageAttr>>(gap::generator<mx::UnsafeBufferUsageAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BindingDecl>(mx::BindingDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GCCAsmStmt>>(std::optional<mx::GCCAsmStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AsTypeExpr>>(gap::generator<mx::AsTypeExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionType>(mx::FunctionType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPDepobjDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPDepobjDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnsafeBufferUsageAttr>>(std::optional<mx::UnsafeBufferUsageAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BindingDecl>>(std::optional<mx::BindingDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmLocallyStreamingAttr>>(gap::generator<mx::ArmLocallyStreamingAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BindingDecl>>(gap::generator<mx::BindingDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LockReturnedAttr>>(std::optional<mx::LockReturnedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnusedAttr>(mx::UnusedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmLocallyStreamingAttr>>(std::optional<mx::ArmLocallyStreamingAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnusedAttr>>(gap::generator<mx::UnusedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CFConsumedAttr>>(gap::generator<mx::CFConsumedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoSpeculativeLoadHardeningAttr>(mx::NoSpeculativeLoadHardeningAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionProtoType>(mx::FunctionProtoType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoSpeculativeLoadHardeningAttr>>(gap::generator<mx::NoSpeculativeLoadHardeningAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StringLiteral>>(gap::generator<mx::StringLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AsTypeExpr>>(std::optional<mx::AsTypeExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDeleteExpr>>(std::optional<mx::CXXDeleteExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::AsTypeExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::AsTypeExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UninitializedAttr>>(std::optional<mx::UninitializedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::BindingDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::BindingDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LifetimeBoundAttr>>(gap::generator<mx::LifetimeBoundAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnusedAttr>>(std::optional<mx::UnusedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionNoProtoType>(mx::FunctionNoProtoType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoSpeculativeLoadHardeningAttr>>(std::optional<mx::NoSpeculativeLoadHardeningAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmBuiltinAliasAttr>>(std::optional<mx::ArmBuiltinAliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AttrKind>(mx::AttrKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnavailableAttr>>(gap::generator<mx::UnavailableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AArch64VectorPcsAttrSpelling>(mx::AArch64VectorPcsAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StringLiteral>>(std::optional<mx::StringLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPCriticalDirective>(mx::OMPCriticalDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LifetimeBoundAttr>>(std::optional<mx::LifetimeBoundAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPCancelDirective>(mx::OMPCancelDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentVectorType>(mx::DependentVectorType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCriticalDirective>>(gap::generator<mx::OMPCriticalDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LeafAttr>>(gap::generator<mx::LeafAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnsafeBufferUsageAttr>(mx::UnsafeBufferUsageAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParmVarDecl>>(std::optional<mx::ParmVarDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnavailableAttr>(mx::UnavailableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArgumentWithTypeTagAttr>>(gap::generator<mx::ArgumentWithTypeTagAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoSanitizeAttr>(mx::NoSanitizeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnavailableAttr>>(std::optional<mx::UnavailableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnsafeBufferUsageAttr>>(gap::generator<mx::UnsafeBufferUsageAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArgumentWithTypeTagAttr>>(std::optional<mx::ArgumentWithTypeTagAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoRandomizeLayoutAttr>(mx::NoRandomizeLayoutAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeVisibilityAttr>>(gap::generator<mx::TypeVisibilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoSanitizeAttr>>(gap::generator<mx::NoSanitizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentSizedExtVectorType>(mx::DependentSizedExtVectorType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCriticalDirective>>(std::optional<mx::OMPCriticalDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnyX86NoCfCheckAttr>>(gap::generator<mx::AnyX86NoCfCheckAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArrayTypeTraitExpr>(mx::ArrayTypeTraitExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LeafAttr>>(std::optional<mx::LeafAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPCriticalDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPCriticalDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDefaultInitExpr>>(gap::generator<mx::CXXDefaultInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArrayInitLoopExpr>(mx::ArrayInitLoopExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LayoutVersionAttr>>(gap::generator<mx::LayoutVersionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArrayTypeTraitExpr>>(gap::generator<mx::ArrayTypeTraitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AddrLabelExpr>>(gap::generator<mx::AddrLabelExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AArch64SVEPcsAttrSpelling>(mx::AArch64SVEPcsAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentBitIntType>(mx::DependentBitIntType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AlwaysInlineAttrSpelling>(mx::AlwaysInlineAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArcWeakrefUnavailableAttr>>(gap::generator<mx::ArcWeakrefUnavailableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUFlatWorkGroupSizeAttrSpelling>(mx::AMDGPUFlatWorkGroupSizeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeVisibilityAttr>>(std::optional<mx::TypeVisibilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnsafeBufferUsageAttr>>(std::optional<mx::UnsafeBufferUsageAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDefaultInitExpr>>(std::optional<mx::CXXDefaultInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUKernelCallAttrSpelling>(mx::AMDGPUKernelCallAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArcWeakrefUnavailableAttr>>(std::optional<mx::ArcWeakrefUnavailableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoSanitizeAttr>>(std::optional<mx::NoSanitizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeTagForDatatypeAttr>>(gap::generator<mx::TypeTagForDatatypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUNumSGPRAttrSpelling>(mx::AMDGPUNumSGPRAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AddrLabelExpr>>(std::optional<mx::AddrLabelExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUNumVGPRAttrSpelling>(mx::AMDGPUNumVGPRAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LayoutVersionAttr>>(std::optional<mx::LayoutVersionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AMDGPUWavesPerEUAttrSpelling>(mx::AMDGPUWavesPerEUAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DependentAddressSpaceType>(mx::DependentAddressSpaceType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VarTemplateSpecializationDecl>>(gap::generator<mx::VarTemplateSpecializationDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeTagForDatatypeAttr>>(std::optional<mx::TypeTagForDatatypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ARMInterruptAttrInterruptType>(mx::ARMInterruptAttrInterruptType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InternalLinkageAttr>>(gap::generator<mx::InternalLinkageAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ARMInterruptAttrSpelling>(mx::ARMInterruptAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnyX86NoCfCheckAttr>>(std::optional<mx::AnyX86NoCfCheckAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AVRInterruptAttrSpelling>(mx::AVRInterruptAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeducedType>(mx::DeducedType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArrayTypeTraitExpr>>(std::optional<mx::ArrayTypeTraitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LTOVisibilityPublicAttr>>(gap::generator<mx::LTOVisibilityPublicAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AVRSignalAttrSpelling>(mx::AVRSignalAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LTOVisibilityPublicAttr>>(std::optional<mx::LTOVisibilityPublicAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ArrayTypeTraitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ArrayTypeTraitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDefaultArgExpr>>(gap::generator<mx::CXXDefaultArgExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AbiTagAttrSpelling>(mx::AbiTagAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeducedTemplateSpecializationType>(mx::DeducedTemplateSpecializationType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AcquireCapabilityAttrSpelling>(mx::AcquireCapabilityAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnyX86InterruptAttr>>(gap::generator<mx::AnyX86InterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AcquireHandleAttrSpelling>(mx::AcquireHandleAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TryAcquireCapabilityAttr>>(gap::generator<mx::TryAcquireCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AddressSpaceAttrSpelling>(mx::AddressSpaceAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AnyX86NoCallerSavedRegistersAttr>>(gap::generator<mx::AnyX86NoCallerSavedRegistersAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UninitializedAttr>(mx::UninitializedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TryAcquireCapabilityAttr>>(std::optional<mx::TryAcquireCapabilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VarTemplateSpecializationDecl>>(std::optional<mx::VarTemplateSpecializationDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDefaultArgExpr>>(std::optional<mx::CXXDefaultArgExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AliasAttrSpelling>(mx::AliasAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnyX86NoCallerSavedRegistersAttr>>(std::optional<mx::AnyX86NoCallerSavedRegistersAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeVisibilityAttr>(mx::TypeVisibilityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TrivialABIAttr>>(gap::generator<mx::TrivialABIAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UninitializedAttr>>(gap::generator<mx::UninitializedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InternalLinkageAttr>>(std::optional<mx::InternalLinkageAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoReturnAttr>(mx::NoReturnAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AutoType>(mx::AutoType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AlignedAttrSpelling>(mx::AlignedAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IntelOclBiccAttr>>(gap::generator<mx::IntelOclBiccAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoProfileFunctionAttr>(mx::NoProfileFunctionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConceptDecl>(mx::ConceptDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoReturnAttr>>(gap::generator<mx::NoReturnAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnyX86InterruptAttr>>(std::optional<mx::AnyX86InterruptAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AllocAlignAttrSpelling>(mx::AllocAlignAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TrivialABIAttr>>(std::optional<mx::TrivialABIAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::VarTemplateSpecializationDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::VarTemplateSpecializationDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlwaysDestroyAttr>>(gap::generator<mx::AlwaysDestroyAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AllocSizeAttrSpelling>(mx::AllocSizeAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ThisCallAttr>>(gap::generator<mx::ThisCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AlwaysDestroyAttrSpelling>(mx::AlwaysDestroyAttrSpelling) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IntelOclBiccAttr>>(std::optional<mx::IntelOclBiccAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCSubscriptRefExpr>>(gap::generator<mx::ObjCSubscriptRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLNumThreadsAttr>>(std::optional<mx::HLSLNumThreadsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AutoType>>(gap::generator<mx::AutoType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLAnnotationAttr>>(gap::generator<mx::HLSLAnnotationAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::InvariantStartOp>>(std::optional<mx::ir::llvm::InvariantStartOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLAnnotationAttr>>(std::optional<mx::HLSLAnnotationAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceMulOp>>(std::optional<mx::ir::llvm::VectorReduceMulOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCInterfaceDecl>>(std::optional<mx::ObjCInterfaceDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AutoType>>(std::optional<mx::AutoType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLSV_GroupIndexAttr>>(gap::generator<mx::HLSLSV_GroupIndexAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AnnotateAttr>>(std::optional<mx::AnnotateAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLSV_GroupIndexAttr>>(std::optional<mx::HLSLSV_GroupIndexAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::IsConstantOp>>(std::optional<mx::ir::llvm::IsConstantOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCProtocolDecl>>(std::optional<mx::ObjCProtocolDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCSubscriptRefExpr>>(std::optional<mx::ObjCSubscriptRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GuardedByAttr>>(gap::generator<mx::GuardedByAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceOrOp>>(std::optional<mx::ir::llvm::VectorReduceOrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Macro>>(gap::generator<mx::Macro>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCSubscriptRefExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCSubscriptRefExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLSV_DispatchThreadIDAttr>>(gap::generator<mx::HLSLSV_DispatchThreadIDAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::IsFPClassOp>(mx::ir::llvm::IsFPClassOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLSV_DispatchThreadIDAttr>>(std::optional<mx::HLSLSV_DispatchThreadIDAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::WhileStmt>>(gap::generator<mx::WhileStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HIPManagedAttr>>(gap::generator<mx::HIPManagedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::IsFPClassOp>>(std::optional<mx::ir::llvm::IsFPClassOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReferenceKind>(mx::ReferenceKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceSMaxOp>(mx::ir::llvm::VectorReduceSMaxOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HIPManagedAttr>>(std::optional<mx::HIPManagedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceSMaxOp>>(std::optional<mx::ir::llvm::VectorReduceSMaxOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GuardedVarAttr>>(gap::generator<mx::GuardedVarAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConceptDecl>(mx::ConceptDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Type>>(gap::generator<mx::Type>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UseHandleAttr>>(gap::generator<mx::UseHandleAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Type>(mx::Type) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConceptDecl>>(std::optional<mx::ConceptDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GuardedVarAttr>>(std::optional<mx::GuardedVarAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConceptDecl>>(gap::generator<mx::ConceptDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GuardedByAttr>>(std::optional<mx::GuardedByAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LifetimeEndOp>(mx::ir::llvm::LifetimeEndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GNUInlineAttr>>(gap::generator<mx::GNUInlineAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::WhileStmt>>(std::optional<mx::WhileStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCImplDecl>>(gap::generator<mx::ObjCImplDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LifetimeEndOp>>(std::optional<mx::ir::llvm::LifetimeEndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateArgument>(mx::TemplateArgument) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceSMinOp>(mx::ir::llvm::VectorReduceSMinOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GNUInlineAttr>>(std::optional<mx::GNUInlineAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceSMinOp>>(std::optional<mx::ir::llvm::VectorReduceSMinOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCImplDecl>>(std::optional<mx::ObjCImplDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::WhileStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::WhileStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateParameterList>(mx::TemplateParameterList) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UseHandleAttr>>(std::optional<mx::UseHandleAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FormatAttr>>(gap::generator<mx::FormatAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LifetimeStartOp>(mx::ir::llvm::LifetimeStartOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionReturnThunksAttr>>(gap::generator<mx::FunctionReturnThunksAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LifetimeStartOp>>(std::optional<mx::ir::llvm::LifetimeStartOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCPropertyImplDecl>>(std::optional<mx::ObjCPropertyImplDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceUMaxOp>(mx::ir::llvm::VectorReduceUMaxOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionReturnThunksAttr>>(std::optional<mx::FunctionReturnThunksAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ConceptDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::ConceptDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXBaseSpecifier>(mx::CXXBaseSpecifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceUMaxOp>>(std::optional<mx::ir::llvm::VectorReduceUMaxOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCPropertyImplDecl>>(gap::generator<mx::ObjCPropertyImplDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCStringLiteral>>(gap::generator<mx::ObjCStringLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FormatAttr>>(std::optional<mx::FormatAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::RoundAndCastToLongLongOp>(mx::ir::llvm::RoundAndCastToLongLongOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<FragmentIdList>(FragmentIdList) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::RoundAndCastToLongLongOp>>(std::optional<mx::ir::llvm::RoundAndCastToLongLongOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FormatArgAttr>>(gap::generator<mx::FormatArgAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceUMinOp>(mx::ir::llvm::VectorReduceUMinOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Designator>(mx::Designator) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceUMinOp>>(std::optional<mx::ir::llvm::VectorReduceUMinOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FormatArgAttr>>(std::optional<mx::FormatArgAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ReleaseHandleAttr>>(gap::generator<mx::ReleaseHandleAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FlattenAttr>>(gap::generator<mx::FlattenAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::Log10Op>(mx::ir::llvm::Log10Op) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXCtorInitializer>(mx::CXXCtorInitializer) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::RoundAndCastToNearestLongLongOp>(mx::ir::llvm::RoundAndCastToNearestLongLongOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXCtorInitializer>>(std::optional<mx::CXXCtorInitializer>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCStringLiteral>>(std::optional<mx::ObjCStringLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FlattenAttr>>(std::optional<mx::FlattenAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::RoundAndCastToNearestLongLongOp>>(std::optional<mx::ir::llvm::RoundAndCastToNearestLongLongOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FlagEnumAttr>>(gap::generator<mx::FlagEnumAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCStringLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCStringLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<bool>>(std::optional<bool>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VectorReduceXorOp>(mx::ir::llvm::VectorReduceXorOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FlagEnumAttr>>(std::optional<mx::FlagEnumAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VectorReduceXorOp>>(std::optional<mx::ir::llvm::VectorReduceXorOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FieldDecl>(mx::FieldDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ReleaseHandleAttr>>(std::optional<mx::ReleaseHandleAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FinalAttr>>(gap::generator<mx::FinalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::Log2Op>(mx::ir::llvm::Log2Op) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclaratorDecl>(mx::DeclaratorDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DesignatedInitUpdateExpr>(mx::DesignatedInitUpdateExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FinalAttr>>(std::optional<mx::FinalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentScopeDeclRefExpr>(mx::DependentScopeDeclRefExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FastCallAttr>>(gap::generator<mx::FastCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DesignatedInitUpdateExpr>>(gap::generator<mx::DesignatedInitUpdateExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ValueDecl>(mx::ValueDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::Log10Op>>(std::optional<mx::ir::llvm::Log10Op>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCImplementationDecl>>(gap::generator<mx::ObjCImplementationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VScaleOp>(mx::ir::llvm::VScaleOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCImplementationDecl>>(std::optional<mx::ObjCImplementationDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VScaleOp>>(std::optional<mx::ir::llvm::VScaleOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NamedDecl>(mx::NamedDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DecltypeType>>(gap::generator<mx::DecltypeType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FastCallAttr>>(std::optional<mx::FastCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::LogOp>(mx::ir::llvm::LogOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnableIfAttr>>(gap::generator<mx::EnableIfAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DesignatedInitUpdateExpr>>(std::optional<mx::DesignatedInitUpdateExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VarDecl>(mx::VarDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::Log2Op>>(std::optional<mx::ir::llvm::Log2Op>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExclusiveTrylockFunctionAttr>>(gap::generator<mx::ExclusiveTrylockFunctionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::Operation>(mx::ir::memref::Operation) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExclusiveTrylockFunctionAttr>>(std::optional<mx::ExclusiveTrylockFunctionAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PassObjectSizeAttr>(mx::PassObjectSizeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VarTemplateDecl>(mx::VarTemplateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::Operation>>(std::optional<mx::ir::memref::Operation>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RedeclarableTemplateDecl>(mx::RedeclarableTemplateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PassObjectSizeAttr>>(gap::generator<mx::PassObjectSizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExcludeFromExplicitInstantiationAttr>>(gap::generator<mx::ExcludeFromExplicitInstantiationAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DecltypeType>>(std::optional<mx::DecltypeType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExcludeFromExplicitInstantiationAttr>>(std::optional<mx::ExcludeFromExplicitInstantiationAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DesignatedInitUpdateExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::DesignatedInitUpdateExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ErrorAttr>>(gap::generator<mx::ErrorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::AssumeAlignmentOp>(mx::ir::memref::AssumeAlignmentOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateDecl>(mx::TemplateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::AssumeAlignmentOp>>(std::optional<mx::ir::memref::AssumeAlignmentOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VarTemplateDecl>>(gap::generator<mx::VarTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::LogOp>>(std::optional<mx::ir::llvm::LogOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ErrorAttr>>(std::optional<mx::ErrorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCIvarRefExpr>(mx::ObjCIvarRefExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnforceTCBLeafAttr>>(gap::generator<mx::EnforceTCBLeafAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCSelectorExpr>>(gap::generator<mx::ObjCSelectorExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Expr>(mx::Expr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PassObjectSizeAttr>>(std::optional<mx::PassObjectSizeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnumExtensibilityAttr>>(gap::generator<mx::EnumExtensibilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::AtomicRMWOp>(mx::ir::memref::AtomicRMWOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnumExtensibilityAttr>>(std::optional<mx::EnumExtensibilityAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::AtomicRMWOp>>(std::optional<mx::ir::memref::AtomicRMWOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ValueStmt>(mx::ValueStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::RoundAndCastToLongOp>(mx::ir::llvm::RoundAndCastToLongOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ValueStmt>>(gap::generator<mx::ValueStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ComplexType>>(gap::generator<mx::ComplexType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnforceTCBLeafAttr>>(std::optional<mx::EnforceTCBLeafAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::RoundAndCastToLongOp>>(std::optional<mx::ir::llvm::RoundAndCastToLongOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EnforceTCBAttr>>(gap::generator<mx::EnforceTCBAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCSelectorExpr>>(std::optional<mx::ObjCSelectorExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyRefExpr>(mx::ObjCPropertyRefExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::CopyOp>(mx::ir::memref::CopyOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCCategoryDecl>>(gap::generator<mx::ObjCCategoryDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::AtomicYieldOp>(mx::ir::memref::AtomicYieldOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCCategoryDecl>>(std::optional<mx::ObjCCategoryDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ComplexType>>(std::optional<mx::ComplexType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCInterfaceDecl>(mx::ObjCInterfaceDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::AtomicYieldOp>>(std::optional<mx::ir::memref::AtomicYieldOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnforceTCBAttr>>(std::optional<mx::EnforceTCBAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCSelectorExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCSelectorExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCContainerDecl>(mx::ObjCContainerDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ParameterABIAttr>(mx::ParameterABIAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EnableIfAttr>>(std::optional<mx::EnableIfAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::RoundAndCastToNearestLongOp>(mx::ir::llvm::RoundAndCastToNearestLongOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DiagnoseIfAttr>>(gap::generator<mx::DiagnoseIfAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ParameterABIAttr>>(gap::generator<mx::ParameterABIAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodDecl>(mx::ObjCMethodDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::RoundAndCastToNearestLongOp>>(std::optional<mx::ir::llvm::RoundAndCastToNearestLongOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCCategoryImplDecl>>(gap::generator<mx::ObjCCategoryImplDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::InitListExpr>(mx::InitListExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::EmptyBasesAttr>>(gap::generator<mx::EmptyBasesAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InitListExpr>>(gap::generator<mx::InitListExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyDecl>(mx::ObjCPropertyDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::CopyOp>>(std::optional<mx::ir::memref::CopyOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCCategoryImplDecl>>(std::optional<mx::ObjCCategoryImplDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MaskedLoadOp>(mx::ir::llvm::MaskedLoadOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::EmptyBasesAttr>>(std::optional<mx::EmptyBasesAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::LoadOp>(mx::ir::memref::LoadOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCIvarDecl>(mx::ObjCIvarDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ParameterABIAttr>>(std::optional<mx::ParameterABIAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DisableTailCallsAttr>>(gap::generator<mx::DisableTailCallsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MaskedLoadOp>>(std::optional<mx::ir::llvm::MaskedLoadOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ImplicitParamDecl>(mx::ImplicitParamDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::GenericAtomicRMWOp>(mx::ir::memref::GenericAtomicRMWOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DisableTailCallsAttr>>(std::optional<mx::DisableTailCallsAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BuiltinType>(mx::BuiltinType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParmVarDecl>(mx::ParmVarDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AttributedType>(mx::AttributedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DisableSanitizerInstrumentationAttr>>(gap::generator<mx::DisableSanitizerInstrumentationAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BuiltinType>>(gap::generator<mx::BuiltinType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCProtocolDecl>(mx::ObjCProtocolDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::GenericAtomicRMWOp>>(std::optional<mx::ir::memref::GenericAtomicRMWOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DisableSanitizerInstrumentationAttr>>(std::optional<mx::DisableSanitizerInstrumentationAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InitListExpr>>(std::optional<mx::InitListExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DiagnoseIfAttr>>(std::optional<mx::DiagnoseIfAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::InitListExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::InitListExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCImplementationDecl>(mx::ObjCImplementationDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BuiltinType>>(std::optional<mx::BuiltinType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlwaysInlineAttr>>(gap::generator<mx::AlwaysInlineAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MaskedStoreOp>(mx::ir::llvm::MaskedStoreOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FieldDecl>>(std::optional<mx::FieldDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MaskedStoreOp>>(std::optional<mx::ir::llvm::MaskedStoreOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCImplDecl>(mx::ObjCImplDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::AllocOp>(mx::ir::memref::AllocOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DiagnoseAsBuiltinAttr>>(gap::generator<mx::DiagnoseAsBuiltinAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::LoadOp>>(std::optional<mx::ir::memref::LoadOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DiagnoseAsBuiltinAttr>>(std::optional<mx::DiagnoseAsBuiltinAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCProtocolExpr>(mx::ObjCProtocolExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyImplDecl>(mx::ObjCPropertyImplDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftIndirectResultAttr>(mx::SwiftIndirectResultAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DestructorAttr>>(gap::generator<mx::DestructorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCMessageExpr>(mx::ObjCMessageExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCCategoryDecl>(mx::ObjCCategoryDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftContextAttr>(mx::SwiftContextAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DestructorAttr>>(std::optional<mx::DestructorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCProtocolExpr>>(gap::generator<mx::ObjCProtocolExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCCategoryImplDecl>(mx::ObjCCategoryImplDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftIndirectResultAttr>>(gap::generator<mx::SwiftIndirectResultAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeprecatedAttr>>(gap::generator<mx::DeprecatedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MatrixColumnMajorLoadOp>(mx::ir::llvm::MatrixColumnMajorLoadOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VariableArrayType>(mx::VariableArrayType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MatrixColumnMajorLoadOp>>(std::optional<mx::ir::llvm::MatrixColumnMajorLoadOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeprecatedAttr>>(std::optional<mx::DeprecatedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::AllocOp>>(std::optional<mx::ir::memref::AllocOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeclOrStmtAttr>>(gap::generator<mx::DeclOrStmtAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BlockPointerType>(mx::BlockPointerType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArrayType>(mx::ArrayType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCProtocolExpr>>(std::optional<mx::ObjCProtocolExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IndirectFieldDecl>(mx::IndirectFieldDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BTFTagAttributedType>(mx::BTFTagAttributedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeclOrStmtAttr>>(std::optional<mx::DeclOrStmtAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftIndirectResultAttr>>(std::optional<mx::SwiftIndirectResultAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXRecordDecl>(mx::CXXRecordDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BlockPointerType>>(gap::generator<mx::BlockPointerType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlwaysInlineAttr>>(std::optional<mx::AlwaysInlineAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCProtocolExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCProtocolExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SuppressAttr>>(gap::generator<mx::SuppressAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::AllocaOp>(mx::ir::memref::AllocaOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RecordDecl>(mx::RecordDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MatrixColumnMajorStoreOp>(mx::ir::llvm::MatrixColumnMajorStoreOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TagDecl>(mx::TagDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::AllocaOp>>(std::optional<mx::ir::memref::AllocaOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SuppressAttr>>(std::optional<mx::SuppressAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MatrixColumnMajorStoreOp>>(std::optional<mx::ir::llvm::MatrixColumnMajorStoreOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoMergeAttr>>(gap::generator<mx::NoMergeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BlockPointerType>>(std::optional<mx::BlockPointerType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeDecl>(mx::TypeDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::AllocaScopeOp>(mx::ir::memref::AllocaScopeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoMergeAttr>>(std::optional<mx::NoMergeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::AllocaScopeOp>>(std::optional<mx::ir::memref::AllocaScopeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypedefNameDecl>(mx::TypedefNameDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftErrorResultAttr>(mx::SwiftErrorResultAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoInlineAttr>>(gap::generator<mx::NoInlineAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SwiftAsyncContextAttr>(mx::SwiftAsyncContextAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXConstructorDecl>(mx::CXXConstructorDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftErrorResultAttr>>(gap::generator<mx::SwiftErrorResultAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoInlineAttr>>(std::optional<mx::NoInlineAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MatrixTransposeOp>(mx::ir::llvm::MatrixTransposeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CountedByAttr>>(gap::generator<mx::CountedByAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::MatrixMultiplyOp>(mx::ir::llvm::MatrixMultiplyOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXMethodDecl>(mx::CXXMethodDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentCoawaitExpr>(mx::DependentCoawaitExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionDecl>(mx::FunctionDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::MatrixMultiplyOp>>(std::optional<mx::ir::llvm::MatrixMultiplyOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DLLImportAttr>>(gap::generator<mx::DLLImportAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DesignatedInitExpr>>(gap::generator<mx::DesignatedInitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DLLImportStaticLocalAttr>>(gap::generator<mx::DLLImportStaticLocalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::AllocaScopeReturnOp>(mx::ir::memref::AllocaScopeReturnOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DLLImportStaticLocalAttr>>(std::optional<mx::DLLImportStaticLocalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BitIntType>>(gap::generator<mx::BitIntType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FunctionTemplateDecl>(mx::FunctionTemplateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BitIntType>(mx::BitIntType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VarDecl>>(std::optional<mx::VarDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::AllocaScopeReturnOp>>(std::optional<mx::ir::memref::AllocaScopeReturnOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FriendDecl>(mx::FriendDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPUnrollDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPUnrollDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DLLImportAttr>>(std::optional<mx::DLLImportAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMasterTaskLoopDirective>>(gap::generator<mx::OMPMasterTaskLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeclaratorDecl>>(gap::generator<mx::DeclaratorDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXMemberCallExpr>>(std::optional<mx::CXXMemberCallExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeclaratorDecl>>(std::optional<mx::DeclaratorDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoReturnAttr>>(std::optional<mx::NoReturnAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ClassTemplateDecl>(mx::ClassTemplateDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXMemberCallExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXMemberCallExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DLLExportAttr>>(gap::generator<mx::DLLExportAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VarDecl>>(std::optional<mx::VarDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DLLExportStaticLocalAttr>>(gap::generator<mx::DLLExportStaticLocalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VarDecl>(mx::VarDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXXDestructorDecl>(mx::CXXDestructorDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VarDecl>>(gap::generator<mx::VarDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DLLExportStaticLocalAttr>>(std::optional<mx::DLLExportStaticLocalAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMasterTaskLoopDirective>>(std::optional<mx::OMPMasterTaskLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TokenTree>(mx::TokenTree) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPMasterTaskLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPMasterTaskLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DLLExportAttr>>(std::optional<mx::DLLExportAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoRandomizeLayoutAttr>>(gap::generator<mx::NoRandomizeLayoutAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RegexQuery>(mx::RegexQuery) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::VarDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::VarDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CountedByAttr>>(std::optional<mx::CountedByAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTileDirective>>(gap::generator<mx::OMPTileDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TokenTreeNode>(mx::TokenTreeNode) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoRandomizeLayoutAttr>>(std::optional<mx::NoRandomizeLayoutAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CleanupAttr>>(gap::generator<mx::CleanupAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CUDAKernelCallExpr>>(gap::generator<mx::CUDAKernelCallExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FieldDecl>>(gap::generator<mx::FieldDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTileDirective>>(std::optional<mx::OMPTileDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroWrapperAttr>>(gap::generator<mx::CoroWrapperAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPTileDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPTileDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArrayType>>(gap::generator<mx::ArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoProfileFunctionAttr>>(gap::generator<mx::NoProfileFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DefineMacroDirective>(mx::DefineMacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMaskedTaskLoopSimdDirective>>(gap::generator<mx::OMPMaskedTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroWrapperAttr>>(std::optional<mx::CoroWrapperAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CUDAKernelCallExpr>>(std::optional<mx::CUDAKernelCallExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroDirective>(mx::MacroDirective) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CUDAKernelCallExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CUDAKernelCallExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroReturnTypeAttr>>(gap::generator<mx::CoroReturnTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::VarTemplateDecl>(mx::VarTemplateDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ExternalSourceSymbolAttr>(mx::ExternalSourceSymbolAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMaskedTaskLoopSimdDirective>>(std::optional<mx::OMPMaskedTaskLoopSimdDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroReturnTypeAttr>>(std::optional<mx::CoroReturnTypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoProfileFunctionAttr>>(std::optional<mx::NoProfileFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArrayType>>(std::optional<mx::ArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VarTemplateDecl>>(std::optional<mx::VarTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::InheritableAttr>(mx::InheritableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::RedeclarableTemplateDecl>(mx::RedeclarableTemplateDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlignValueAttr>(mx::AlignValueAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPMaskedTaskLoopSimdDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPMaskedTaskLoopSimdDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroOnlyDestroyWhenCompleteAttr>>(gap::generator<mx::CoroOnlyDestroyWhenCompleteAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TemplateDecl>(mx::TemplateDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VariableArrayType>>(gap::generator<mx::VariableArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlignValueAttr>>(gap::generator<mx::AlignValueAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroOnlyDestroyWhenCompleteAttr>>(std::optional<mx::CoroOnlyDestroyWhenCompleteAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TemplateDecl>>(gap::generator<mx::TemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VariableArrayType>>(std::optional<mx::VariableArrayType>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoMips16Attr>(mx::NoMips16Attr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AliasAttr>(mx::AliasAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoMips16Attr>>(gap::generator<mx::NoMips16Attr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroLifetimeBoundAttr>>(gap::generator<mx::CoroLifetimeBoundAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPForSimdDirective>(mx::OMPForSimdDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroLifetimeBoundAttr>>(std::optional<mx::CoroLifetimeBoundAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPLoopDirective>>(gap::generator<mx::OMPLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AbiTagAttr>(mx::AbiTagAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlignValueAttr>>(std::optional<mx::AlignValueAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConvergentAttr>>(gap::generator<mx::ConvergentAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateDecl>>(std::optional<mx::TemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeAttr>(mx::TypeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TemplateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TemplateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroDisableLifetimeBoundAttr>>(gap::generator<mx::CoroDisableLifetimeBoundAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXUnresolvedConstructExpr>(mx::CXXUnresolvedConstructExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroDisableLifetimeBoundAttr>>(std::optional<mx::CoroDisableLifetimeBoundAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UserDefinedLiteral>>(gap::generator<mx::UserDefinedLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SPtrAttr>(mx::SPtrAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoMips16Attr>>(std::optional<mx::NoMips16Attr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Ptr64Attr>(mx::Ptr64Attr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPLoopDirective>>(std::optional<mx::OMPLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConvergentAttr>>(std::optional<mx::ConvergentAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConsumableAttr>>(gap::generator<mx::ConsumableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPMaskedTaskLoopDirective>(mx::OMPMaskedTaskLoopDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Ptr32Attr>(mx::Ptr32Attr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AliasAttr>(mx::AliasAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConsumableSetOnReadAttr>>(gap::generator<mx::ConsumableSetOnReadAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPFlushDirective>(mx::OMPFlushDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConsumableSetOnReadAttr>>(std::optional<mx::ConsumableSetOnReadAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMaskedTaskLoopDirective>>(gap::generator<mx::OMPMaskedTaskLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLPrivateAddressSpaceAttr>(mx::OpenCLPrivateAddressSpaceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AliasAttr>>(gap::generator<mx::AliasAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConsumableAutoCastAttr>>(gap::generator<mx::ConsumableAutoCastAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UserDefinedLiteral>>(std::optional<mx::UserDefinedLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IndirectFieldDecl>>(gap::generator<mx::IndirectFieldDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::UserDefinedLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::UserDefinedLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLLocalAddressSpaceAttr>(mx::OpenCLLocalAddressSpaceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoMicroMipsAttr>(mx::NoMicroMipsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConsumableAutoCastAttr>>(std::optional<mx::ConsumableAutoCastAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoMicroMipsAttr>>(gap::generator<mx::NoMicroMipsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IndirectFieldDecl>>(std::optional<mx::IndirectFieldDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMaskedTaskLoopDirective>>(std::optional<mx::OMPMaskedTaskLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalHostAddressSpaceAttr>(mx::OpenCLGlobalHostAddressSpaceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AliasAttr>>(std::optional<mx::AliasAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConsumableAttr>>(std::optional<mx::ConsumableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPMaskedTaskLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPMaskedTaskLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalDeviceAddressSpaceAttr>(mx::OpenCLGlobalDeviceAddressSpaceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RedeclarableTemplateDecl>>(gap::generator<mx::RedeclarableTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstructorAttr>>(gap::generator<mx::ConstructorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoMicroMipsAttr>>(std::optional<mx::NoMicroMipsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalAddressSpaceAttr>(mx::OpenCLGlobalAddressSpaceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AbiTagAttr>(mx::AbiTagAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstructorAttr>>(std::optional<mx::ConstructorAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::SPtrAttr>(mx::SPtrAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstInitAttr>>(gap::generator<mx::ConstInitAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AbiTagAttr>>(gap::generator<mx::AbiTagAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGenericAddressSpaceAttr>(mx::OpenCLGenericAddressSpaceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RedeclarableTemplateDecl>>(std::optional<mx::RedeclarableTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenCLConstantAddressSpaceAttr>(mx::OpenCLConstantAddressSpaceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::RedeclarableTemplateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::RedeclarableTemplateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstInitAttr>>(std::optional<mx::ConstInitAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoInstrumentFunctionAttr>(mx::NoInstrumentFunctionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstAttr>>(gap::generator<mx::ConstAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoDestroyAttr>(mx::NoDestroyAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeDecl>>(gap::generator<mx::TypeDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoInstrumentFunctionAttr>>(gap::generator<mx::NoInstrumentFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCKindOfAttr>(mx::ObjCKindOfAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXUuidofExpr>(mx::CXXUuidofExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstAttr>>(std::optional<mx::ConstAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXTypeidExpr>(mx::CXXTypeidExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCInertUnsafeUnretainedAttr>(mx::ObjCInertUnsafeUnretainedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXUuidofExpr>>(gap::generator<mx::CXXUuidofExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CommonAttr>>(gap::generator<mx::CommonAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AbiTagAttr>>(std::optional<mx::AbiTagAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeDecl>>(std::optional<mx::TypeDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPInteropDirective>(mx::OMPInteropDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MethodRefFlags>(mx::MethodRefFlags) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPCanonicalLoop>(mx::OMPCanonicalLoop) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclCategory>(mx::DeclCategory) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPInteropDirective>>(gap::generator<mx::OMPInteropDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Token>(mx::Token) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoInstrumentFunctionAttr>>(std::optional<mx::NoInstrumentFunctionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DiagnoseIfAttr>(mx::DiagnoseIfAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXUuidofExpr>>(std::optional<mx::CXXUuidofExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXBoolLiteralExpr>>(gap::generator<mx::CXXBoolLiteralExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXUuidofExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXUuidofExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXTemporaryObjectExpr>>(gap::generator<mx::CXXTemporaryObjectExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeAttr>(mx::TypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ModifiableType>(mx::ModifiableType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPInteropDirective>>(std::optional<mx::OMPInteropDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PseudoKind>(mx::PseudoKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Ptr64Attr>(mx::Ptr64Attr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskwaitDirective>>(gap::generator<mx::OMPTaskwaitDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeAttr>>(gap::generator<mx::TypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DiagnoseAsBuiltinAttr>(mx::DiagnoseAsBuiltinAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPInteropDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPInteropDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXTemporaryObjectExpr>>(std::optional<mx::CXXTemporaryObjectExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPGenericLoopDirective>(mx::OMPGenericLoopDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LifetimeExtendedTemporaryDecl>>(std::optional<mx::LifetimeExtendedTemporaryDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPForDirective>(mx::OMPForDirective) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MultiVersionKind>(mx::MultiVersionKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPGenericLoopDirective>>(gap::generator<mx::OMPGenericLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::EntityCategory>(mx::EntityCategory) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoDuplicateAttr>(mx::NoDuplicateAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LifetimeExtendedTemporaryDecl>>(gap::generator<mx::LifetimeExtendedTemporaryDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VarTemplateDecl>>(gap::generator<mx::VarTemplateDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DestructorAttr>(mx::DestructorAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoDebugAttr>(mx::NoDebugAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskwaitDirective>>(std::optional<mx::OMPTaskwaitDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoDuplicateAttr>>(gap::generator<mx::NoDuplicateAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NameKind>(mx::NameKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeAttr>>(std::optional<mx::TypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Attr>(mx::Attr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPGenericLoopDirective>>(std::optional<mx::OMPGenericLoopDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NeedExtraManglingDecl>(mx::NeedExtraManglingDecl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoDuplicateAttr>>(std::optional<mx::NoDuplicateAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeprecatedAttr>(mx::DeprecatedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPGenericLoopDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPGenericLoopDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTaskgroupDirective>>(gap::generator<mx::OMPTaskgroupDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::VarTemplateDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::VarTemplateDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXBoolLiteralExpr>>(std::optional<mx::CXXBoolLiteralExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PathKind>(mx::PathKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NestedNameSpecifierDependence>(mx::NestedNameSpecifierDependence) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SequenceTokenTreeNode>>(std::optional<mx::SequenceTokenTreeNode>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::MacroKind>(mx::MacroKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftErrorResultAttr>>(std::optional<mx::SwiftErrorResultAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DeclOrStmtAttr>(mx::DeclOrStmtAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExprWithCleanups>>(std::optional<mx::ExprWithCleanups>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskgroupDirective>>(std::optional<mx::OMPTaskgroupDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DLLImportAttr>>(gap::generator<mx::DLLImportAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NonOdrUseReason>(mx::NonOdrUseReason) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TokenTreeNode>>(gap::generator<mx::TokenTreeNode>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BuiltinReferenceKind>(mx::BuiltinReferenceKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FileType>(mx::FileType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BlockExpr>>(gap::generator<mx::BlockExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UninitializedAttr>>(std::optional<mx::UninitializedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlwaysInlineAttr>(mx::AlwaysInlineAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AssertCapabilityAttr>>(gap::generator<mx::AssertCapabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NonceObjCInterface>(mx::NonceObjCInterface) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypedefNameDecl>(mx::TypedefNameDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXBindTemporaryExpr>>(gap::generator<mx::CXXBindTemporaryExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::CastOp>(mx::ir::memref::CastOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSPropertySubscriptExpr>>(gap::generator<mx::MSPropertySubscriptExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ExprWithCleanups, mx::ir::Operation>>>(gap::generator<std::pair<mx::ExprWithCleanups, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NullabilityKind>(mx::NullabilityKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypedefNameDecl>>(std::optional<mx::TypedefNameDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SuppressAttr>(mx::SuppressAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CompilerName>(mx::CompilerName) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXBindTemporaryExpr>>(std::optional<mx::CXXBindTemporaryExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypedefNameDecl>>(gap::generator<mx::TypedefNameDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSPropertySubscriptExpr>>(std::optional<mx::MSPropertySubscriptExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::CastOp>>(std::optional<mx::ir::memref::CastOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTaskDirective>>(std::optional<mx::OMPTaskDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCDirectMembersAttr>>(gap::generator<mx::ObjCDirectMembersAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareReductionInitKind>(mx::OMPDeclareReductionInitKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TargetLanguage>(mx::TargetLanguage) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoMergeAttr>(mx::NoMergeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::CollapseShapeOp>(mx::ir::memref::CollapseShapeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCBridgeCastKind>(mx::ObjCBridgeCastKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroVAOptArgument>(mx::MacroVAOptArgument) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCPropertyDecl>>(gap::generator<mx::ObjCPropertyDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DLLImportAttr>>(std::optional<mx::DLLImportAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::NoInlineAttr>(mx::NoInlineAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::CollapseShapeOp>>(std::optional<mx::ir::memref::CollapseShapeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCImplementationControl>(mx::ObjCImplementationControl) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroVAOptArgument>>(gap::generator<mx::MacroVAOptArgument>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TokenTreeNodeKind>(mx::TokenTreeNodeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AssertCapabilityAttr>>(std::optional<mx::AssertCapabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BlockExpr>>(std::optional<mx::BlockExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftContextAttr>>(gap::generator<mx::SwiftContextAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSPropertyRefExpr>>(std::optional<mx::MSPropertyRefExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::DeallocOp>(mx::ir::memref::DeallocOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCInstanceTypeFamily>(mx::ObjCInstanceTypeFamily) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::DimOp>(mx::ir::memref::DimOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TokenKind>(mx::TokenKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnavailableAttr>>(gap::generator<mx::UnavailableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DLLImportStaticLocalAttr>(mx::DLLImportStaticLocalAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCDirectMembersAttr>>(std::optional<mx::ObjCDirectMembersAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetUpdateDirective>>(gap::generator<mx::OMPTargetUpdateDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArraySubscriptExpr>>(gap::generator<mx::ArraySubscriptExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetUpdateDirective>>(std::optional<mx::OMPTargetUpdateDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::DeallocOp>>(std::optional<mx::ir::memref::DeallocOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BlockDecl>>(gap::generator<mx::BlockDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::TypedefNameDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::TypedefNameDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCLifetime>(mx::ObjCLifetime) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::DimOp>>(std::optional<mx::ir::memref::DimOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TokenCategory>(mx::TokenCategory) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftContextAttr>>(std::optional<mx::SwiftContextAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MSPropertyDecl>>(gap::generator<mx::MSPropertyDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DLLExportStaticLocalAttr>>(gap::generator<mx::DLLExportStaticLocalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DLLImportAttr>(mx::DLLImportAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroVAOptArgument>>(std::optional<mx::MacroVAOptArgument>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCMethodFamily>(mx::ObjCMethodFamily) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnavailableAttr>>(std::optional<mx::UnavailableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IndexStatus>(mx::IndexStatus) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VarTemplatePartialSpecializationDecl>>(gap::generator<mx::VarTemplatePartialSpecializationDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetTeamsDirective>>(gap::generator<mx::OMPTargetTeamsDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AsmLabelAttr>>(gap::generator<mx::AsmLabelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BlockDecl>>(std::optional<mx::BlockDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArraySubscriptExpr>>(std::optional<mx::ArraySubscriptExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DLLExportStaticLocalAttr>(mx::DLLExportStaticLocalAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstantExpr>>(gap::generator<mx::ConstantExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSPropertyDecl>>(std::optional<mx::MSPropertyDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<int64_t>>(std::optional<int64_t>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCPropertyQueryKind>(mx::ObjCPropertyQueryKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCDirectAttr>>(gap::generator<mx::ObjCDirectAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::IncludePathLocation>(mx::IncludePathLocation) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ArraySubscriptExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ArraySubscriptExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetTeamsDirective>>(std::optional<mx::OMPTargetTeamsDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::DMAStartOp>(mx::ir::memref::DMAStartOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCStringFormatFamily>(mx::ObjCStringFormatFamily) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::DMAStartOp>>(std::optional<mx::ir::memref::DMAStartOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PathKind>(mx::PathKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DLLExportStaticLocalAttr>>(std::optional<mx::DLLExportStaticLocalAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::DLLExportAttr>(mx::DLLExportAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VarTemplatePartialSpecializationDecl>>(std::optional<mx::VarTemplatePartialSpecializationDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::LambdaExpr>>(gap::generator<mx::LambdaExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwiftAsyncContextAttr>>(gap::generator<mx::SwiftAsyncContextAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCSubstitutionContext>(mx::ObjCSubstitutionContext) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AsmLabelAttr>>(std::optional<mx::AsmLabelAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::FileType>(mx::FileType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroConcatenate>(mx::MacroConcatenate) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CountedByAttr>(mx::CountedByAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstantExpr>>(std::optional<mx::ConstantExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::LambdaExpr>>(std::optional<mx::LambdaExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::VarTemplatePartialSpecializationDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::VarTemplatePartialSpecializationDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ObjCTypeParamVariance>(mx::ObjCTypeParamVariance) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroConcatenate>>(gap::generator<mx::MacroConcatenate>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CompilerName>(mx::CompilerName) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCDirectAttr>>(std::optional<mx::ObjCDirectAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetParallelDirective>>(gap::generator<mx::OMPTargetParallelDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::DMAWaitOp>(mx::ir::memref::DMAWaitOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroWrapperAttr>(mx::CoroWrapperAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeVisibilityAttr>>(gap::generator<mx::TypeVisibilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetParallelDirective>>(std::optional<mx::OMPTargetParallelDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ConstantExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ConstantExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OnOffSwitch>(mx::OnOffSwitch) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::DMAWaitOp>>(std::optional<mx::ir::memref::DMAWaitOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TargetLanguage>(mx::TargetLanguage) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DLLExportAttr>(mx::DLLExportAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OnStackType>(mx::OnStackType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwiftAsyncContextAttr>>(std::optional<mx::SwiftAsyncContextAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroReturnTypeAttr>(mx::CoroReturnTypeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DLLExportAttr>>(gap::generator<mx::DLLExportAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AcquireCapabilityAttrSpelling>(mx::AcquireCapabilityAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::ExpandShapeOp>(mx::ir::memref::ExpandShapeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPAdjustArgsOpKind>(mx::OpenMPAdjustArgsOpKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::ExpandShapeOp>>(std::optional<mx::ir::memref::ExpandShapeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroOnlyDestroyWhenCompleteAttr>(mx::CoroOnlyDestroyWhenCompleteAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeVisibilityAttr>>(std::optional<mx::TypeVisibilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPAtClauseKind>(mx::OpenMPAtClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArtificialAttr>(mx::ArtificialAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BinaryOperator>>(gap::generator<mx::BinaryOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCDesignatedInitializerAttr>(mx::ObjCDesignatedInitializerAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroLifetimeBoundAttr>(mx::CoroLifetimeBoundAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroConcatenate>>(std::optional<mx::MacroConcatenate>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetExitDataDirective>>(gap::generator<mx::OMPTargetExitDataDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::ExtractAlignedPointerAsIndexOp>(mx::ir::memref::ExtractAlignedPointerAsIndexOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPAtomicDefaultMemOrderClauseKind>(mx::OpenMPAtomicDefaultMemOrderClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArtificialAttr>>(gap::generator<mx::ArtificialAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetExitDataDirective>>(std::optional<mx::OMPTargetExitDataDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCDesignatedInitializerAttr>>(gap::generator<mx::ObjCDesignatedInitializerAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BinaryOperator>>(std::optional<mx::BinaryOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::ExtractAlignedPointerAsIndexOp>>(std::optional<mx::ir::memref::ExtractAlignedPointerAsIndexOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPBindClauseKind>(mx::OpenMPBindClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DLLExportAttr>>(std::optional<mx::DLLExportAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CoroDisableLifetimeBoundAttr>(mx::CoroDisableLifetimeBoundAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::ExtractStridedMetadataOp>(mx::ir::memref::ExtractStridedMetadataOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDefaultmapClauseKind>(mx::OpenMPDefaultmapClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OSConsumedAttr>(mx::OSConsumedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateArgument>>(std::optional<mx::TemplateArgument>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OSConsumedAttr>>(gap::generator<mx::OSConsumedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetDirective>>(gap::generator<mx::OMPTargetDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConditionalOperator>(mx::ConditionalOperator) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConvergentAttr>(mx::ConvergentAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArrayInitLoopExpr>>(gap::generator<mx::ArrayInitLoopExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IntegerLiteral>>(gap::generator<mx::IntegerLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::ExtractStridedMetadataOp>>(std::optional<mx::ir::memref::ExtractStridedMetadataOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDefaultmapClauseModifier>(mx::OpenMPDefaultmapClauseModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArtificialAttr>>(std::optional<mx::ArtificialAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetEnterDataDirective>>(gap::generator<mx::OMPTargetEnterDataDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::RecordDecl>>(std::optional<mx::RecordDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConsumableSetOnReadAttr>(mx::ConsumableSetOnReadAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCDesignatedInitializerAttr>>(std::optional<mx::ObjCDesignatedInitializerAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetEnterDataDirective>>(std::optional<mx::OMPTargetEnterDataDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeTagForDatatypeAttr>(mx::TypeTagForDatatypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IntegerLiteral>>(std::optional<mx::IntegerLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeTagForDatatypeAttr>>(gap::generator<mx::TypeTagForDatatypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDependClauseKind>(mx::OpenMPDependClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXConversionDecl>(mx::CXXConversionDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDeviceClauseModifier>(mx::OpenMPDeviceClauseModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroStringify>(mx::MacroStringify) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAutoCastAttr>(mx::ConsumableAutoCastAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXConversionDecl>>(gap::generator<mx::CXXConversionDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TemplateParameterList>>(std::optional<mx::TemplateParameterList>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::RecordDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::RecordDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImaginaryLiteral>>(gap::generator<mx::ImaginaryLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroStringify>>(gap::generator<mx::MacroStringify>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDeviceType>(mx::OpenMPDeviceType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExtVectorElementExpr>(mx::ExtVectorElementExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAttr>(mx::ConsumableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FloatingLiteral>>(gap::generator<mx::FloatingLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetDirective>>(std::optional<mx::OMPTargetDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::GetGlobalOp>(mx::ir::memref::GetGlobalOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ImplicitValueInitExpr>>(gap::generator<mx::ImplicitValueInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CountedByAttr>(mx::CountedByAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDistScheduleClauseKind>(mx::OpenMPDistScheduleClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OSConsumedAttr>>(std::optional<mx::OSConsumedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AtomicExpr>>(gap::generator<mx::AtomicExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArrayInitLoopExpr>>(std::optional<mx::ArrayInitLoopExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImplicitValueInitExpr>>(std::optional<mx::ImplicitValueInitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CountedByAttr>>(gap::generator<mx::CountedByAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CompoundAssignOperator>>(gap::generator<mx::CompoundAssignOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::GetGlobalOp>>(std::optional<mx::ir::memref::GetGlobalOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstructorAttr>(mx::ConstructorAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ArrayInitLoopExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ArrayInitLoopExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPDoacrossClauseModifier>(mx::OpenMPDoacrossClauseModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmNewAttr>(mx::ArmNewAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPSingleDirective>>(gap::generator<mx::OMPSingleDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeTagForDatatypeAttr>>(std::optional<mx::TypeTagForDatatypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CompoundAssignOperator>>(std::optional<mx::CompoundAssignOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCClassStubAttr>(mx::ObjCClassStubAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<std::variant<mx::NamedDecl, mx::DefineMacroDirective, mx::File>>>(gap::generator<std::variant<mx::NamedDecl, mx::DefineMacroDirective, mx::File>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXConversionDecl>>(std::optional<mx::CXXConversionDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPGrainsizeClauseModifier>(mx::OpenMPGrainsizeClauseModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmNewAttr>>(gap::generator<mx::ArmNewAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstInitAttr>(mx::ConstInitAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCClassStubAttr>>(gap::generator<mx::ObjCClassStubAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTargetDataDirective>>(gap::generator<mx::OMPTargetDataDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::GlobalOp>(mx::ir::memref::GlobalOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTargetDataDirective>>(std::optional<mx::OMPTargetDataDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FloatingLiteral>>(std::optional<mx::FloatingLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPLastprivateModifier>(mx::OpenMPLastprivateModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXConversionDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXConversionDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ConstAttr>(mx::ConstAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::GlobalOp>>(std::optional<mx::ir::memref::GlobalOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ImaginaryLiteral>>(std::optional<mx::ImaginaryLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroStringify>>(std::optional<mx::MacroStringify>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPLinearClauseKind>(mx::OpenMPLinearClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FloatingLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::FloatingLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AtomicExpr>>(std::optional<mx::AtomicExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CountedByAttr>>(std::optional<mx::CountedByAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CommonAttr>(mx::CommonAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NonNullAttr>(mx::NonNullAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPMapClauseKind>(mx::OpenMPMapClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NonNullAttr>>(gap::generator<mx::NonNullAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GNUNullExpr>>(gap::generator<mx::GNUNullExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmNewAttr>>(std::optional<mx::ArmNewAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPMapModifierKind>(mx::OpenMPMapModifierKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCClassStubAttr>>(std::optional<mx::ObjCClassStubAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ColdAttr>(mx::ColdAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::MemorySpaceCastOp>(mx::ir::memref::MemorySpaceCastOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPSingleDirective>>(std::optional<mx::OMPSingleDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TryAcquireCapabilityAttr>(mx::TryAcquireCapabilityAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AsTypeExpr>>(gap::generator<mx::AsTypeExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::MemorySpaceCastOp>>(std::optional<mx::ir::memref::MemorySpaceCastOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::GenericSelectionExpr>>(gap::generator<mx::GenericSelectionExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TryAcquireCapabilityAttr>>(gap::generator<mx::TryAcquireCapabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPMotionModifierKind>(mx::OpenMPMotionModifierKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::PrefetchOp>(mx::ir::memref::PrefetchOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GenericSelectionExpr>>(std::optional<mx::GenericSelectionExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroExpansion>(mx::MacroExpansion) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CodeSegAttr>(mx::CodeSegAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroParameterSubstitution>(mx::MacroParameterSubstitution) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPSectionDirective>>(gap::generator<mx::OMPSectionDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::RankOp>(mx::ir::memref::RankOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AsTypeExpr>>(std::optional<mx::AsTypeExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroExpansion>>(gap::generator<mx::MacroExpansion>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPNumTasksClauseModifier>(mx::OpenMPNumTasksClauseModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NonNullAttr>>(std::optional<mx::NonNullAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CodeModelAttr>(mx::CodeModelAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroWrapperAttr>(mx::CoroWrapperAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPSectionsDirective>>(gap::generator<mx::OMPSectionsDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::PrefetchOp>>(std::optional<mx::ir::memref::PrefetchOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPOrderClauseKind>(mx::OpenMPOrderClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroWrapperAttr>>(gap::generator<mx::CoroWrapperAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArrayTypeTraitExpr>>(gap::generator<mx::ArrayTypeTraitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCBoxableAttr>(mx::ObjCBoxableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExternalSourceSymbolAttr>>(std::optional<mx::ExternalSourceSymbolAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArrayInitIndexExpr>(mx::ArrayInitIndexExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPOrderClauseModifier>(mx::OpenMPOrderClauseModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NoEscapeAttr>(mx::NoEscapeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CmseNSEntryAttr>(mx::CmseNSEntryAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmLocallyStreamingAttr>(mx::ArmLocallyStreamingAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPSectionsDirective>>(std::optional<mx::OMPSectionsDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCBoxableAttr>>(gap::generator<mx::ObjCBoxableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ValueDecl>>(gap::generator<mx::ValueDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AnyX86NoCfCheckAttr>(mx::AnyX86NoCfCheckAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::InheritableAttr>>(gap::generator<mx::InheritableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArrayInitIndexExpr>>(gap::generator<mx::ArrayInitIndexExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPReductionClauseModifier>(mx::OpenMPReductionClauseModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmLocallyStreamingAttr>>(gap::generator<mx::ArmLocallyStreamingAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArrayTypeTraitExpr>>(std::optional<mx::ArrayTypeTraitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TryAcquireCapabilityAttr>>(std::optional<mx::TryAcquireCapabilityAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CleanupAttr>(mx::CleanupAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::RankOp>>(std::optional<mx::ir::memref::RankOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NamedDecl>>(gap::generator<mx::NamedDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroWrapperAttr>>(std::optional<mx::CoroWrapperAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::InheritableAttr>>(std::optional<mx::InheritableAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXDeductionGuideDecl>(mx::CXXDeductionGuideDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPScheduleClauseKind>(mx::OpenMPScheduleClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NSConsumedAttr>(mx::NSConsumedAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::GNUNullExpr>>(std::optional<mx::GNUNullExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareMapperDecl>(mx::OMPDeclareMapperDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CapturedRecordAttr>(mx::CapturedRecordAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CalledOnceAttr>(mx::CalledOnceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArraySubscriptExpr>>(gap::generator<mx::ArraySubscriptExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXDeductionGuideDecl>>(gap::generator<mx::CXXDeductionGuideDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPScheduleClauseModifier>(mx::OpenMPScheduleClauseModifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NSConsumedAttr>>(gap::generator<mx::NSConsumedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExternalSourceSymbolAttr>>(gap::generator<mx::ExternalSourceSymbolAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::FixedPointLiteral>(mx::FixedPointLiteral) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OpenMPSeverityClauseKind>(mx::OpenMPSeverityClauseKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroExpansion>>(std::optional<mx::MacroExpansion>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CapabilityAttr>(mx::CapabilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ExpressionTraitExpr>(mx::ExpressionTraitExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPSectionDirective>>(std::optional<mx::OMPSectionDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FixedPointLiteral>>(gap::generator<mx::FixedPointLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FullExpr>>(gap::generator<mx::FullExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::ReallocOp>(mx::ir::memref::ReallocOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArraySubscriptExpr>>(std::optional<mx::ArraySubscriptExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArrayInitIndexExpr>>(std::optional<mx::ArrayInitIndexExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OverloadedOperatorKind>(mx::OverloadedOperatorKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::ReallocOp>>(std::optional<mx::ir::memref::ReallocOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FunctionParmPackExpr>>(gap::generator<mx::FunctionParmPackExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCBoxableAttr>>(std::optional<mx::ObjCBoxableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CallbackAttr>(mx::CallbackAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmLocallyStreamingAttr>>(std::optional<mx::ArmLocallyStreamingAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPScopeDirective>>(gap::generator<mx::OMPScopeDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ArrayInitIndexExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ArrayInitIndexExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::OverloadsShown>(mx::OverloadsShown) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TrivialABIAttr>(mx::TrivialABIAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArrayInitLoopExpr>>(gap::generator<mx::ArrayInitLoopExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ThisCallAttr>(mx::ThisCallAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FunctionParmPackExpr>>(std::optional<mx::FunctionParmPackExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TrivialABIAttr>>(gap::generator<mx::TrivialABIAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Reference>(mx::Reference) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::ReinterpretCastOp>(mx::ir::memref::ReinterpretCastOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CallableWhenAttr>(mx::CallableWhenAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXDeductionGuideDecl>>(std::optional<mx::CXXDeductionGuideDecl>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParameterABI>(mx::ParameterABI) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::ReinterpretCastOp>>(std::optional<mx::ir::memref::ReinterpretCastOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPScopeDirective>>(std::optional<mx::OMPScopeDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NSConsumedAttr>>(std::optional<mx::NSConsumedAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArrayInitLoopExpr>>(std::optional<mx::ArrayInitLoopExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroReturnTypeAttr>(mx::CoroReturnTypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ParenLocsOffsets>(mx::ParenLocsOffsets) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FixedPointLiteral>>(std::optional<mx::FixedPointLiteral>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CXX11NoReturnAttr>(mx::CXX11NoReturnAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXRecordDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXRecordDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPScanDirective>>(gap::generator<mx::OMPScanDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroLifetimeBoundAttr>(mx::CoroLifetimeBoundAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaFPKind>(mx::PragmaFPKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroReturnTypeAttr>>(gap::generator<mx::CoroReturnTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FullExpr>>(std::optional<mx::FullExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXDeductionGuideDecl, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXDeductionGuideDecl, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDASharedAttr>(mx::CUDASharedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MacroArgument>(mx::MacroArgument) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArrayInitIndexExpr>>(gap::generator<mx::ArrayInitIndexExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::FixedPointLiteral, mx::ir::Operation>>>(gap::generator<std::pair<mx::FixedPointLiteral, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaFloatControlKind>(mx::PragmaFloatControlKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MacroArgument>>(std::optional<mx::MacroArgument>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPScanDirective>>(std::optional<mx::OMPScanDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::MacroArgument>>(gap::generator<mx::MacroArgument>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDALaunchBoundsAttr>(mx::CUDALaunchBoundsAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPReferencedVarAttr>(mx::OMPReferencedVarAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExprWithCleanups>>(gap::generator<mx::ExprWithCleanups>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPCaptureKindAttr>(mx::OMPCaptureKindAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaMSCommentKind>(mx::PragmaMSCommentKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArmBuiltinAliasAttr>(mx::ArmBuiltinAliasAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArrayInitIndexExpr>>(std::optional<mx::ArrayInitIndexExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPReferencedVarAttr>>(gap::generator<mx::OMPReferencedVarAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaMSPointersToMembersKind>(mx::PragmaMSPointersToMembersKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArcWeakrefUnavailableAttr>(mx::ArcWeakrefUnavailableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDAInvalidTargetAttr>(mx::CUDAInvalidTargetAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmBuiltinAliasAttr>>(gap::generator<mx::ArmBuiltinAliasAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExprWithCleanups>>(std::optional<mx::ExprWithCleanups>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TrivialABIAttr>>(std::optional<mx::TrivialABIAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaMSStructKind>(mx::PragmaMSStructKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::StoreOp>(mx::ir::memref::StoreOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDAHostAttr>(mx::CUDAHostAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::ReshapeOp>(mx::ir::memref::ReshapeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelSectionsDirective>>(gap::generator<mx::OMPParallelSectionsDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroReturnTypeAttr>>(std::optional<mx::CoroReturnTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PragmaSectionFlag>(mx::PragmaSectionFlag) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::ReshapeOp>>(std::optional<mx::ir::memref::ReshapeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConditionalOperator>>(gap::generator<mx::ConditionalOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IFuncAttr>(mx::IFuncAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelSectionsDirective>>(std::optional<mx::OMPParallelSectionsDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BuiltinAliasAttr>(mx::BuiltinAliasAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AbstractConditionalOperator>>(gap::generator<mx::AbstractConditionalOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IFuncAttr>>(gap::generator<mx::IFuncAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDAGlobalAttr>(mx::CUDAGlobalAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPReferencedVarAttr>>(std::optional<mx::OMPReferencedVarAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::PredefinedIdentKind>(mx::PredefinedIdentKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmBuiltinAliasAttr>>(std::optional<mx::ArmBuiltinAliasAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AbstractConditionalOperator>>(std::optional<mx::AbstractConditionalOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::StoreOp>>(std::optional<mx::ir::memref::StoreOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstantExpr>>(gap::generator<mx::ConstantExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AbstractConditionalOperator>(mx::AbstractConditionalOperator) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Qualified>(mx::Qualified) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TransparentUnionAttr>(mx::TransparentUnionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceBuiltinTextureTypeAttr>(mx::CUDADeviceBuiltinTextureTypeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::BinaryConditionalOperator>(mx::BinaryConditionalOperator) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstantExpr>>(std::optional<mx::ConstantExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TestTypestateAttr>(mx::TestTypestateAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RangeExprOffset>(mx::RangeExprOffset) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AbstractConditionalOperator>>(gap::generator<mx::AbstractConditionalOperator>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceBuiltinSurfaceTypeAttr>(mx::CUDADeviceBuiltinSurfaceTypeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TransparentUnionAttr>>(gap::generator<mx::TransparentUnionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CodeAlignAttr>>(gap::generator<mx::CodeAlignAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IFuncAttr>>(std::optional<mx::IFuncAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConditionalOperator>>(std::optional<mx::ConditionalOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroOnlyDestroyWhenCompleteAttr>(mx::CoroOnlyDestroyWhenCompleteAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RangeLocOffset>(mx::RangeLocOffset) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroDisableLifetimeBoundAttr>(mx::CoroDisableLifetimeBoundAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AlignValueAttr>>(gap::generator<mx::AlignValueAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroOnlyDestroyWhenCompleteAttr>>(gap::generator<mx::CoroOnlyDestroyWhenCompleteAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMasterDirective>>(gap::generator<mx::OMPParallelMasterDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::TransposeOp>(mx::ir::memref::TransposeOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FloatingLiteral>>(gap::generator<mx::FloatingLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<std::vector<mx::CXXBaseSpecifier>>>(std::optional<std::vector<mx::CXXBaseSpecifier>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDADeviceAttr>(mx::CUDADeviceAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::memref::ViewOp>(mx::ir::memref::ViewOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMasterDirective>>(std::optional<mx::OMPParallelMasterDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::memref::TransposeOp>>(std::optional<mx::ir::memref::TransposeOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RecordArgPassingKind>(mx::RecordArgPassingKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArgumentWithTypeTagAttr>>(gap::generator<mx::ArgumentWithTypeTagAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AlignValueAttr>>(std::optional<mx::AlignValueAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclareSimdDeclAttr>>(gap::generator<mx::OMPDeclareSimdDeclAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::RefQualifierKind>(mx::RefQualifierKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AbstractConditionalOperator>>(std::optional<mx::AbstractConditionalOperator>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AliasAttr>>(gap::generator<mx::AliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclareSimdDeclAttr>(mx::OMPDeclareSimdDeclAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CUDAConstantAttr>(mx::CUDAConstantAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ArgumentWithTypeTagAttr>(mx::ArgumentWithTypeTagAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FloatingLiteral>>(std::optional<mx::FloatingLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OMPDeclarativeDirectiveValueDecl>(mx::OMPDeclarativeDirectiveValueDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::VAArgExpr>>(gap::generator<mx::VAArgExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXConstructorDecl>(mx::CXXConstructorDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReservedIdentifierStatus>(mx::ReservedIdentifierStatus) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCAtDefsFieldDecl>(mx::ObjCAtDefsFieldDecl) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BinaryConditionalOperator>>(gap::generator<mx::BinaryConditionalOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::MSInheritanceModel>>(std::optional<mx::MSInheritanceModel>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CPUSpecificAttr>(mx::CPUSpecificAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::TBAATypeDescriptorAttr>>(std::optional<mx::ir::llvm::TBAATypeDescriptorAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AliasAttr>>(std::optional<mx::AliasAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<PackedStmtId>(PackedStmtId) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BinaryConditionalOperator>>(std::optional<mx::BinaryConditionalOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXUnresolvedConstructExpr>>(gap::generator<mx::CXXUnresolvedConstructExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::FixedPointLiteral>>(gap::generator<mx::FixedPointLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinOrOp>(mx::ir::hl::BinOrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ReservedLiteralSuffixIdStatus>(mx::ReservedLiteralSuffixIdStatus) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BitIntType>>(std::optional<mx::BitIntType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AbiTagAttr>>(gap::generator<mx::AbiTagAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::TBAATagAttr>>(std::optional<mx::ir::llvm::TBAATagAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPOrderedDirective>>(gap::generator<mx::OMPOrderedDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinOrAssignOp>>(std::optional<mx::ir::hl::BinOrAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CPUDispatchAttr>(mx::CPUDispatchAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCMessageExpr>>(gap::generator<mx::ObjCMessageExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelMaskedDirective>>(gap::generator<mx::OMPParallelMaskedDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PreserveMostAttr>>(gap::generator<mx::PreserveMostAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SFINAEResponse>(mx::SFINAEResponse) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::VScaleRangeAttr>(mx::ir::llvm::VScaleRangeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelMaskedDirective>>(std::optional<mx::OMPParallelMaskedDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXUnresolvedConstructExpr>>(std::optional<mx::CXXUnresolvedConstructExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::FixedPointLiteral>>(std::optional<mx::FixedPointLiteral>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::VScaleRangeAttr>>(std::optional<mx::ir::llvm::VScaleRangeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AbiTagAttr>>(std::optional<mx::AbiTagAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::TargetFeaturesAttr>(mx::ir::llvm::TargetFeaturesAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SYCLMajorVersion>(mx::SYCLMajorVersion) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXUnresolvedConstructExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXUnresolvedConstructExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFUnknownTransferAttr>(mx::CFUnknownTransferAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinOrOp>>(std::optional<mx::ir::hl::BinOrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeAttr>>(gap::generator<mx::TypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCMessageExpr>>(std::optional<mx::ObjCMessageExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::VAArgExpr>>(std::optional<mx::VAArgExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::TargetFeaturesAttr>>(std::optional<mx::ir::llvm::TargetFeaturesAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SanitizerOrdinal>(mx::SanitizerOrdinal) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PreserveMostAttr>>(std::optional<mx::PreserveMostAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExpressionTraitExpr>>(gap::generator<mx::ExpressionTraitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BTFTagAttributedType>>(gap::generator<mx::BTFTagAttributedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFReturnsRetainedAttr>(mx::CFReturnsRetainedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCMessageExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCMessageExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SelectorLocationsKind>(mx::SelectorLocationsKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::IntegerOverflowFlagsAttr>(mx::ir::llvm::IntegerOverflowFlagsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeAttr>>(std::optional<mx::TypeAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::IntegerOverflowFlagsAttr>>(std::optional<mx::ir::llvm::IntegerOverflowFlagsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnaryOperator>>(gap::generator<mx::UnaryOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinShlAssignOp>(mx::ir::hl::BinShlAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ExtVectorElementExpr>>(gap::generator<mx::ExtVectorElementExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BTFTagAttributedType>>(std::optional<mx::BTFTagAttributedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SPtrAttr>>(gap::generator<mx::SPtrAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FastmathFlagsAttr>(mx::ir::llvm::FastmathFlagsAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFReturnsNotRetainedAttr>(mx::CFReturnsNotRetainedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinShlAssignOp>>(std::optional<mx::ir::hl::BinShlAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPParallelDirective>>(gap::generator<mx::OMPParallelDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::Type>(mx::ir::llvm::Type) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ShaderStage>(mx::ShaderStage) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FastmathFlagsAttr>>(std::optional<mx::ir::llvm::FastmathFlagsAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExtVectorElementExpr>>(std::optional<mx::ExtVectorElementExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PreserveAllAttr>>(gap::generator<mx::PreserveAllAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPParallelDirective>>(std::optional<mx::OMPParallelDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::Type>>(std::optional<mx::ir::llvm::Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnaryOperator>>(std::optional<mx::UnaryOperator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinShlOp>(mx::ir::hl::BinShlOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SignReturnAddressKeyKind>(mx::SignReturnAddressKeyKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinShlOp>>(std::optional<mx::ir::hl::BinShlOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFICanonicalJumpTableAttr>(mx::CFICanonicalJumpTableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ArrayType>(mx::ir::llvm::ArrayType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SPtrAttr>>(std::optional<mx::SPtrAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ArrayType>>(std::optional<mx::ir::llvm::ArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Ptr64Attr>>(gap::generator<mx::Ptr64Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AttributedType>>(gap::generator<mx::AttributedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SignReturnAddressScopeKind>(mx::SignReturnAddressScopeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FunctionType>(mx::ir::llvm::FunctionType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFGuardAttr>(mx::CFGuardAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PreserveAllAttr>>(std::optional<mx::PreserveAllAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SignedOverflowBehaviorTy>(mx::SignedOverflowBehaviorTy) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FunctionType>>(std::optional<mx::ir::llvm::FunctionType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Ptr64Attr>>(std::optional<mx::Ptr64Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinXorAssignOp>(mx::ir::hl::BinXorAssignOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CFAuditedTransferAttr>(mx::CFAuditedTransferAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXTypeidExpr>>(gap::generator<mx::CXXTypeidExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SourceLocIdentKind>(mx::SourceLocIdentKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinXorAssignOp>>(std::optional<mx::ir::hl::BinXorAssignOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Ptr32Attr>>(gap::generator<mx::Ptr32Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AttributedType>>(std::optional<mx::AttributedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ExpressionTraitExpr>>(std::optional<mx::ExpressionTraitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ir::Type>>(gap::generator<mx::ir::Type>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPOrderedDirective>>(std::optional<mx::OMPOrderedDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::PointerType>(mx::ir::llvm::PointerType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypoExpr>>(gap::generator<mx::TypoExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::PointerType>>(std::optional<mx::ir::llvm::PointerType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SpecialMemberFlags>(mx::SpecialMemberFlags) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinXorOp>(mx::ir::hl::BinXorOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::CDeclAttr>(mx::CDeclAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXTypeidExpr>>(std::optional<mx::CXXTypeidExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnaryExprOrTypeTraitExpr>>(gap::generator<mx::UnaryExprOrTypeTraitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PreferredTypeAttr>(mx::PreferredTypeAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Ptr32Attr>>(std::optional<mx::Ptr32Attr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinXorOp>>(std::optional<mx::ir::hl::BinXorOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::UnaryExprOrTypeTraitExpr>>(std::optional<mx::UnaryExprOrTypeTraitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::FixedVectorType>(mx::ir::llvm::FixedVectorType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SpecifierKind>(mx::SpecifierKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PreferredTypeAttr>>(gap::generator<mx::PreferredTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AttributedStmt>>(gap::generator<mx::AttributedStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIvarRefExpr>>(gap::generator<mx::ObjCIvarRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::C11NoReturnAttr>(mx::C11NoReturnAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::FixedVectorType>>(std::optional<mx::ir::llvm::FixedVectorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMetaDirective>>(gap::generator<mx::OMPMetaDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXTypeidExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXTypeidExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Designator>>(std::optional<mx::Designator>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::EmptyTokenTreeNode>(mx::EmptyTokenTreeNode) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StackProtectorMode>(mx::StackProtectorMode) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NullabilityKind>>(std::optional<mx::NullabilityKind>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AttributedStmt>>(std::optional<mx::AttributedStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::ScalableVectorType>(mx::ir::llvm::ScalableVectorType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BuiltinAttr>(mx::BuiltinAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::ScalableVectorType>>(std::optional<mx::ir::llvm::ScalableVectorType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StorageClass>(mx::StorageClass) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BreakOp>(mx::ir::hl::BreakOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLPrivateAddressSpaceAttr>>(gap::generator<mx::OpenCLPrivateAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BinaryCondOp>(mx::ir::hl::BinaryCondOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMetaDirective>>(std::optional<mx::OMPMetaDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AtomicType>(mx::AtomicType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLPrivateAddressSpaceAttr>>(std::optional<mx::OpenCLPrivateAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AtomicType>>(gap::generator<mx::AtomicType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypoExpr>>(std::optional<mx::TypoExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BinaryCondOp>>(std::optional<mx::ir::hl::BinaryCondOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StorageDuration>(mx::StorageDuration) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PreferredTypeAttr>>(std::optional<mx::PreferredTypeAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BlocksAttr>(mx::BlocksAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::TargetExtType>(mx::ir::llvm::TargetExtType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwitchStmt>>(gap::generator<mx::SwitchStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIvarRefExpr>>(std::optional<mx::ObjCIvarRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMasterDirective>>(gap::generator<mx::OMPMasterDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::TargetExtType>>(std::optional<mx::ir::llvm::TargetExtType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StoredNameKind>(mx::StoredNameKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCIvarRefExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCIvarRefExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLLocalAddressSpaceAttr>>(gap::generator<mx::OpenCLLocalAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AtomicType>>(std::optional<mx::AtomicType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BTFDeclTagAttr>(mx::BTFDeclTagAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AShrOp>(mx::ir::llvm::AShrOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TypeTraitExpr>>(gap::generator<mx::TypeTraitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::Operation>(mx::ir::llvm::Operation) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLLocalAddressSpaceAttr>>(std::optional<mx::OpenCLLocalAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::Operation>>(std::optional<mx::ir::llvm::Operation>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwitchStmt>>(std::optional<mx::SwitchStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BreakOp>>(std::optional<mx::ir::hl::BreakOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StoredSpecifierKind>(mx::StoredSpecifierKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AddOp>(mx::ir::llvm::AddOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMasterDirective>>(std::optional<mx::OMPMasterDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AShrOp>>(std::optional<mx::ir::llvm::AShrOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BPFPreserveStaticOffsetAttr>(mx::BPFPreserveStaticOffsetAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BuiltinBitCastOp>(mx::ir::hl::BuiltinBitCastOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TypeTraitExpr>>(std::optional<mx::TypeTraitExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PreferredNameAttr>(mx::PreferredNameAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StrictFlexArraysLevelKind>(mx::StrictFlexArraysLevelKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PreferredNameAttr>>(gap::generator<mx::PreferredNameAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLGlobalHostAddressSpaceAttr>>(gap::generator<mx::OpenCLGlobalHostAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BuiltinBitCastOp>>(std::optional<mx::ir::hl::BuiltinBitCastOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SwitchCase>>(gap::generator<mx::SwitchCase>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IncompleteArrayType>(mx::IncompleteArrayType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::StringLiteralKind>(mx::StringLiteralKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXThrowExpr>(mx::CXXThrowExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLGlobalHostAddressSpaceAttr>>(std::optional<mx::OpenCLGlobalHostAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXStdInitializerListExpr>(mx::CXXStdInitializerListExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::BPFPreserveAccessIndexAttr>(mx::BPFPreserveAccessIndexAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::IncompleteArrayType>>(gap::generator<mx::IncompleteArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPMaskedDirective>>(gap::generator<mx::OMPMaskedDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXThrowExpr>>(gap::generator<mx::CXXThrowExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SubExpr>(mx::SubExpr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::BuiltinTypesCompatiblePOp>(mx::ir::hl::BuiltinTypesCompatiblePOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SwitchCase>>(std::optional<mx::SwitchCase>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeclKind>(mx::DeclKind) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AvailableOnlyInDefaultEvalMethodAttr>(mx::AvailableOnlyInDefaultEvalMethodAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AddOp>>(std::optional<mx::ir::llvm::AddOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLGlobalDeviceAddressSpaceAttr>>(gap::generator<mx::OpenCLGlobalDeviceAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::BuiltinTypesCompatiblePOp>>(std::optional<mx::ir::hl::BuiltinTypesCompatiblePOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPMaskedDirective>>(std::optional<mx::OMPMaskedDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PreferredNameAttr>>(std::optional<mx::PreferredNameAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SubStmt>(mx::SubStmt) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::IncompleteArrayType>>(std::optional<mx::IncompleteArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLGlobalDeviceAddressSpaceAttr>>(std::optional<mx::OpenCLGlobalDeviceAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXThrowExpr>>(std::optional<mx::CXXThrowExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SubstNonTypeTemplateParmPackExpr>>(gap::generator<mx::SubstNonTypeTemplateParmPackExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXThrowExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXThrowExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AvailabilityAttr>(mx::AvailabilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCIsaExpr>(mx::ObjCIsaExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstNonTypeTemplateParmPackExpr>>(std::optional<mx::SubstNonTypeTemplateParmPackExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AddrSpaceCastOp>(mx::ir::llvm::AddrSpaceCastOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::SyncScope>(mx::SyncScope) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCEncodeExpr>(mx::ObjCEncodeExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLGlobalAddressSpaceAttr>>(gap::generator<mx::OpenCLGlobalAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIsaExpr>>(gap::generator<mx::ObjCIsaExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Syntax>(mx::Syntax) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AddrSpaceCastOp>>(std::optional<mx::ir::llvm::AddrSpaceCastOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AssumptionAttr>(mx::AssumptionAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CallOp>(mx::ir::hl::CallOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLGlobalAddressSpaceAttr>>(std::optional<mx::OpenCLGlobalAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CStyleCastOp>(mx::ir::hl::CStyleCastOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPLoopBasedDirective>>(gap::generator<mx::OMPLoopBasedDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CStyleCastOp>>(std::optional<mx::ir::hl::CStyleCastOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StmtExpr>>(gap::generator<mx::StmtExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangTextSectionAttr>(mx::PragmaClangTextSectionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TQ>(mx::TQ) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DependentSizedArrayType>(mx::DependentSizedArrayType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPLoopBasedDirective>>(std::optional<mx::OMPLoopBasedDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangRelroSectionAttr>(mx::PragmaClangRelroSectionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DefaultStmt>>(gap::generator<mx::DefaultStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangTextSectionAttr>>(gap::generator<mx::PragmaClangTextSectionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AssumeAlignedAttr>(mx::AssumeAlignedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentSizedArrayType>>(gap::generator<mx::DependentSizedArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SubstNonTypeTemplateParmExpr>>(gap::generator<mx::SubstNonTypeTemplateParmExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AddressOfOp>(mx::ir::llvm::AddressOfOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TagTypeKind>(mx::TagTypeKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AddressOfOp>>(std::optional<mx::ir::llvm::AddressOfOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLGenericAddressSpaceAttr>>(gap::generator<mx::OpenCLGenericAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIsaExpr>>(std::optional<mx::ObjCIsaExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DefaultStmt>>(std::optional<mx::DefaultStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CaseOp>(mx::ir::hl::CaseOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NonTypeTemplateParmDecl>>(gap::generator<mx::NonTypeTemplateParmDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AndOp>(mx::ir::llvm::AndOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AVRInterruptAttrSpelling>(mx::AVRInterruptAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CallOp>>(std::optional<mx::ir::hl::CallOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLGenericAddressSpaceAttr>>(std::optional<mx::OpenCLGenericAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentSizedArrayType>>(std::optional<mx::DependentSizedArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AssertSharedLockAttr>(mx::AssertSharedLockAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::ObjCIsaExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::ObjCIsaExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TailPaddingUseRules>(mx::TailPaddingUseRules) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AllocaOp>(mx::ir::llvm::AllocaOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NonTypeTemplateParmDecl>>(std::optional<mx::NonTypeTemplateParmDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AllocaOp>>(std::optional<mx::ir::llvm::AllocaOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCKindOfAttr>>(gap::generator<mx::ObjCKindOfAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangTextSectionAttr>>(std::optional<mx::PragmaClangTextSectionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPUnrollDirective>>(gap::generator<mx::OMPUnrollDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::CaseOp>>(std::optional<mx::ir::hl::CaseOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RedeclarableTemplateDecl>>(gap::generator<mx::RedeclarableTemplateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AndOp>>(std::optional<mx::ir::llvm::AndOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CaseStmt>>(gap::generator<mx::CaseStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXThisExpr>(mx::CXXThisExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateArgumentDependence>(mx::TemplateArgumentDependence) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CXXScalarValueInitExpr>(mx::CXXScalarValueInitExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AssertExclusiveLockAttr>(mx::AssertExclusiveLockAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CXXThisExpr>>(gap::generator<mx::CXXThisExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLConstantAddressSpaceAttr>>(gap::generator<mx::OpenCLConstantAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstantArrayType>(mx::ConstantArrayType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPLoopTransformationDirective>>(gap::generator<mx::OMPLoopTransformationDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DecayedType>(mx::DecayedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLConstantAddressSpaceAttr>>(std::optional<mx::OpenCLConstantAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConstantArrayType>>(gap::generator<mx::ConstantArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateNameDependence>(mx::TemplateNameDependence) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ChooseExprOp>(mx::ir::hl::ChooseExprOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPLoopTransformationDirective>>(std::optional<mx::OMPLoopTransformationDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangRodataSectionAttr>(mx::PragmaClangRodataSectionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AssertCapabilityAttr>(mx::AssertCapabilityAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ChooseExprOp>>(std::optional<mx::ir::hl::ChooseExprOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CaseStmt>>(std::optional<mx::CaseStmt>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::PragmaClangDataSectionAttr>(mx::PragmaClangDataSectionAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TemplateSpecializationKind>(mx::TemplateSpecializationKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::PragmaClangRodataSectionAttr>>(gap::generator<mx::PragmaClangRodataSectionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCKindOfAttr>>(std::optional<mx::ObjCKindOfAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AtomicCmpXchgOp>(mx::ir::llvm::AtomicCmpXchgOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AsmLabelAttr>(mx::AsmLabelAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AtomicCmpXchgOp>>(std::optional<mx::ir::llvm::AtomicCmpXchgOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TextDiagnosticFormat>(mx::TextDiagnosticFormat) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConstantArrayType>>(std::optional<mx::ConstantArrayType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPUnrollDirective>>(std::optional<mx::OMPUnrollDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CXXThisExpr>>(std::optional<mx::CXXThisExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ThreadModelKind>(mx::ThreadModelKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::CXXThisExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::CXXThisExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArtificialAttr>(mx::ArtificialAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::ClassDeclOp>(mx::ir::hl::ClassDeclOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCGCAttr>>(gap::generator<mx::ObjCGCAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCIndirectCopyRestoreExpr>(mx::ObjCIndirectCopyRestoreExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCInertUnsafeUnretainedAttr>>(gap::generator<mx::ObjCInertUnsafeUnretainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ObjCDictionaryLiteral>(mx::ObjCDictionaryLiteral) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPRequiresDecl>>(gap::generator<mx::OMPRequiresDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::hl::ClassDeclOp>>(std::optional<mx::ir::hl::ClassDeclOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ThreadStorageClassSpecifier>(mx::ThreadStorageClassSpecifier) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::PragmaClangRodataSectionAttr>>(std::optional<mx::PragmaClangRodataSectionAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCInertUnsafeUnretainedAttr>>(std::optional<mx::ObjCInertUnsafeUnretainedAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ObjCIndirectCopyRestoreExpr>>(gap::generator<mx::ObjCIndirectCopyRestoreExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmNewAttr>(mx::ArmNewAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::BitcastOp>(mx::ir::llvm::BitcastOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPTileDirective>>(gap::generator<mx::OMPTileDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::llvm::AtomicRMWOp>(mx::ir::llvm::AtomicRMWOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SubstNonTypeTemplateParmExpr>>(std::optional<mx::SubstNonTypeTemplateParmExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ir::llvm::AtomicRMWOp>>(std::optional<mx::ir::llvm::AtomicRMWOp>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AccessSpecDecl>>(gap::generator<mx::AccessSpecDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::AdjustedType>(mx::AdjustedType) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TrailingAllocKind>(mx::TrailingAllocKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::TypeWithKeyword>(mx::TypeWithKeyword) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::AccessSpecDecl>>(std::optional<mx::AccessSpecDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::AdjustedType>>(gap::generator<mx::AdjustedType>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmLocallyStreamingAttr>(mx::ArmLocallyStreamingAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ir::hl::CmpOp>(mx::ir::hl::CmpOp) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TranslationUnitKind>(mx::TranslationUnitKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCIndirectCopyRestoreExpr>>(std::optional<mx::ObjCIndirectCopyRestoreExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ObjCGCAttr>>(std::optional<mx::ObjCGCAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SPtrAttr>>(gap::generator<mx::SPtrAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPTileDirective>>(std::optional<mx::OMPTileDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroOnlyDestroyWhenCompleteAttr>>(std::optional<mx::CoroOnlyDestroyWhenCompleteAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NoDerefAttr>>(gap::generator<mx::NoDerefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DesignatedInitExpr>>(std::optional<mx::DesignatedInitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TrivialAutoVarInitKind>(mx::TrivialAutoVarInitKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPFlushDirective>>(gap::generator<mx::OMPFlushDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArmBuiltinAliasAttr>(mx::ArmBuiltinAliasAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DesignatedInitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::DesignatedInitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::StmtExpr>>(std::optional<mx::StmtExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SPtrAttr>>(std::optional<mx::SPtrAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPLoopDirective>>(gap::generator<mx::OMPLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPFlushDirective>>(std::optional<mx::OMPFlushDirective>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeDependence>(mx::TypeDependence) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroLifetimeBoundAttr>>(gap::generator<mx::CoroLifetimeBoundAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NoDerefAttr>>(std::optional<mx::NoDerefAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPFlushDirective, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPFlushDirective, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArgumentWithTypeTagAttr>(mx::ArgumentWithTypeTagAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Ptr64Attr>>(gap::generator<mx::Ptr64Attr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPThreadPrivateDecl>>(gap::generator<mx::OMPThreadPrivateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroLifetimeBoundAttr>>(std::optional<mx::CoroLifetimeBoundAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SourceLocExpr>>(gap::generator<mx::SourceLocExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Ptr64Attr>>(std::optional<mx::Ptr64Attr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPDeclarativeDirectiveDecl>>(gap::generator<mx::OMPDeclarativeDirectiveDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoawaitExpr>(mx::CoawaitExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeLocClass>(mx::TypeLocClass) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentScopeDeclRefExpr>>(gap::generator<mx::DependentScopeDeclRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPLoopDirective>>(std::optional<mx::OMPLoopDirective>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CoroDisableLifetimeBoundAttr>>(gap::generator<mx::CoroDisableLifetimeBoundAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPDeclarativeDirectiveDecl>>(std::optional<mx::OMPDeclarativeDirectiveDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::MSDependentExistsStmt>(mx::MSDependentExistsStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ArcWeakrefUnavailableAttr>(mx::ArcWeakrefUnavailableAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPCanonicalLoop>>(gap::generator<mx::OMPCanonicalLoop>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLParamModifierAttr>>(gap::generator<mx::HLSLParamModifierAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::Ptr32Attr>(mx::Ptr32Attr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeOfKind>(mx::TypeOfKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::Ptr32Attr>>(gap::generator<mx::Ptr32Attr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLParamModifierAttr>>(std::optional<mx::HLSLParamModifierAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentScopeDeclRefExpr>>(std::optional<mx::DependentScopeDeclRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SourceLocExpr>>(std::optional<mx::SourceLocExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CoroDisableLifetimeBoundAttr>>(std::optional<mx::CoroDisableLifetimeBoundAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeSpecifierSign>(mx::TypeSpecifierSign) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DependentScopeDeclRefExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::DependentScopeDeclRefExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnyX86NoCfCheckAttr>(mx::AnyX86NoCfCheckAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPCanonicalLoop>>(std::optional<mx::OMPCanonicalLoop>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::CmseNSCallAttr>>(gap::generator<mx::CmseNSCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OMPCanonicalLoop, mx::ir::Operation>>>(gap::generator<std::pair<mx::OMPCanonicalLoop, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeSpecifierType>(mx::TypeSpecifierType) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::Ptr32Attr>>(std::optional<mx::Ptr32Attr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SizeOfPackExpr>>(gap::generator<mx::SizeOfPackExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConvergentAttr>(mx::ConvergentAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPThreadPrivateDecl>>(std::optional<mx::OMPThreadPrivateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConvergentAttr>>(gap::generator<mx::ConvergentAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnyX86NoCallerSavedRegistersAttr>(mx::AnyX86NoCallerSavedRegistersAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLPrivateAddressSpaceAttr>(mx::OpenCLPrivateAddressSpaceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::HLSLGroupSharedAddressSpaceAttr>>(gap::generator<mx::HLSLGroupSharedAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLPrivateAddressSpaceAttr>>(gap::generator<mx::OpenCLPrivateAddressSpaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeSpecifierWidth>(mx::TypeSpecifierWidth) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConvergentAttr>>(std::optional<mx::ConvergentAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::HLSLGroupSharedAddressSpaceAttr>>(std::optional<mx::HLSLGroupSharedAddressSpaceAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::CoroutineSuspendExpr>(mx::CoroutineSuspendExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnyX86InterruptAttr>(mx::AnyX86InterruptAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DependentCoawaitExpr>>(gap::generator<mx::DependentCoawaitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SizeOfPackExpr>>(std::optional<mx::SizeOfPackExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLPrivateAddressSpaceAttr>>(std::optional<mx::OpenCLPrivateAddressSpaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeSpecifiersPipe>(mx::TypeSpecifiersPipe) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::DeclRefExpr>(mx::DeclRefExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::ARMInterruptAttrSpelling>(mx::ARMInterruptAttrSpelling) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::DeclRefExpr>>(gap::generator<mx::DeclRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::CmseNSCallAttr>>(std::optional<mx::CmseNSCallAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConsumableSetOnReadAttr>(mx::ConsumableSetOnReadAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::TypeTrait>(mx::TypeTrait) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConsumableSetOnReadAttr>>(gap::generator<mx::ConsumableSetOnReadAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AnalyzerNoReturnAttr>(mx::AnalyzerNoReturnAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DependentCoawaitExpr>>(std::optional<mx::DependentCoawaitExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPRequiresDecl>>(std::optional<mx::OMPRequiresDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DependentCoawaitExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::DependentCoawaitExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::BTFTypeTagAttr>>(gap::generator<mx::BTFTypeTagAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::DeclRefExpr>>(std::optional<mx::DeclRefExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<std::vector<mx::TemplateArgument>>>(std::optional<std::vector<mx::TemplateArgument>>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLLocalAddressSpaceAttr>(mx::OpenCLLocalAddressSpaceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnaryExprOrTypeTrait>(mx::UnaryExprOrTypeTrait) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLLocalAddressSpaceAttr>>(gap::generator<mx::OpenCLLocalAddressSpaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlwaysDestroyAttr>(mx::AlwaysDestroyAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::DeclRefExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::DeclRefExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OMPAllocateDecl>>(gap::generator<mx::OMPAllocateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConsumableSetOnReadAttr>>(std::optional<mx::ConsumableSetOnReadAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::UnaryOperatorKind>(mx::UnaryOperatorKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLLocalAddressSpaceAttr>>(std::optional<mx::OpenCLLocalAddressSpaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::BTFTypeTagAttr>>(std::optional<mx::BTFTypeTagAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAutoCastAttr>(mx::ConsumableAutoCastAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AllocSizeAttr>(mx::AllocSizeAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstructorAttr>(mx::ConstructorAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ShuffleVectorExpr>>(gap::generator<mx::ShuffleVectorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConsumableAutoCastAttr>>(gap::generator<mx::ConsumableAutoCastAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::APValueKind>(mx::APValueKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::UnresolvedLookupExpr>(mx::UnresolvedLookupExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OMPAllocateDecl>>(std::optional<mx::OMPAllocateDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalHostAddressSpaceAttr>(mx::OpenCLGlobalHostAddressSpaceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmStreamingAttr>>(gap::generator<mx::ArmStreamingAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalAddressSpaceAttr>(mx::OpenCLGlobalAddressSpaceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ShuffleVectorExpr>>(std::optional<mx::ShuffleVectorExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLGlobalHostAddressSpaceAttr>>(gap::generator<mx::OpenCLGlobalHostAddressSpaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VectorKind>(mx::VectorKind) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OverloadExpr>(mx::OverloadExpr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AllocAlignAttr>(mx::AllocAlignAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConsumableAutoCastAttr>>(std::optional<mx::ConsumableAutoCastAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmStreamingCompatibleAttr>>(gap::generator<mx::ArmStreamingCompatibleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::UnresolvedLookupExpr>>(gap::generator<mx::UnresolvedLookupExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmStreamingCompatibleAttr>>(std::optional<mx::ArmStreamingCompatibleAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OverloadExpr>>(gap::generator<mx::OverloadExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::Visibility>(mx::Visibility) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::NullStmt>(mx::NullStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::TranslationUnitDecl>>(gap::generator<mx::TranslationUnitDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::IndirectGotoStmt>(mx::IndirectGotoStmt) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlignedAttr>(mx::AlignedAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::NullStmt>>(gap::generator<mx::NullStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VisibilityForcedKinds>(mx::VisibilityForcedKinds) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OpenCLGlobalHostAddressSpaceAttr>>(std::optional<mx::OpenCLGlobalHostAddressSpaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmStreamingAttr>>(std::optional<mx::ArmStreamingAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::OverloadExpr>>(std::optional<mx::OverloadExpr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlignNaturalAttr>(mx::AlignNaturalAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConsumableAttr>(mx::ConsumableAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::RequiresExpr>>(gap::generator<mx::RequiresExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::ConstInitAttr>(mx::ConstInitAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::TranslationUnitDecl>>(std::optional<mx::TranslationUnitDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ConsumableAttr>>(gap::generator<mx::ConsumableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::VisibilityFromDLLStorageClassKinds>(mx::VisibilityFromDLLStorageClassKinds) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::OverloadExpr, mx::ir::Operation>>>(gap::generator<std::pair<mx::OverloadExpr, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::ArmPreservesAttr>>(gap::generator<mx::ArmPreservesAttr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::NullStmt>>(std::optional<mx::NullStmt>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::SYCLUniqueStableNameExpr>>(gap::generator<mx::SYCLUniqueStableNameExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<std::pair<mx::NullStmt, mx::ir::Operation>>>(gap::generator<std::pair<mx::NullStmt, mx::ir::Operation>>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::SYCLUniqueStableNameExpr>>(std::optional<mx::SYCLUniqueStableNameExpr>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGlobalDeviceAddressSpaceAttr>(mx::OpenCLGlobalDeviceAddressSpaceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AttributeSyntax>(mx::AttributeSyntax) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<mx::OpenCLGenericAddressSpaceAttr>(mx::OpenCLGenericAddressSpaceAttr) noexcept;
+template MX_EXPORT SharedPyObject *to_python<mx::AlignMac68kAttr>(mx::AlignMac68kAttr) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::OpenCLGlobalDeviceAddressSpaceAttr>>(gap::generator<mx::OpenCLGlobalDeviceAddressSpaceAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<gap::generator<mx::StaticAssertDecl>>(gap::generator<mx::StaticAssertDecl>) noexcept;
 
-template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ConsumableAttr>>(std::optional<mx::ConsumableAttr>) noexcept;
+template MX_EXPORT SharedPyObject *to_python<std::optional<mx::ArmPreservesAttr>>(std::optional<mx::ArmPreservesAttr>) noexcept;
 }  // namespace mx
diff --git a/bindings/Python/Generated/Fragment.cpp b/bindings/Python/Generated/Fragment.cpp
index 9f4f1c973..5b3240056 100644
--- a/bindings/Python/Generated/Fragment.cpp
+++ b/bindings/Python/Generated/Fragment.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -317,15 +316,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::containing(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::containing(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -346,7 +337,7 @@ static PyMethodDef gMethods[] = {
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/ChoiceTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/ChoiceTokenTreeNode.cpp
index 655a9ca1a..9745ec762 100644
--- a/bindings/Python/Generated/Frontend/ChoiceTokenTreeNode.cpp
+++ b/bindings/Python/Generated/Frontend/ChoiceTokenTreeNode.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/Compilation.cpp b/bindings/Python/Generated/Frontend/Compilation.cpp
index eeef01eab..d0237948d 100644
--- a/bindings/Python/Generated/Frontend/Compilation.cpp
+++ b/bindings/Python/Generated/Frontend/Compilation.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -121,16 +120,6 @@ static PyGetSetDef gProperties[] = {
     PyDoc_STR("Wrapper for mx::Compilation::id"),
     nullptr,
   },
-  {
-    "ir",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->ir());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::Compilation::ir"),
-    nullptr,
-  },
   {
     "fragments",
     reinterpret_cast<getter>(
@@ -439,7 +428,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::containing(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/ConditionalMacroDirective.cpp b/bindings/Python/Generated/Frontend/ConditionalMacroDirective.cpp
index 68e41363e..c417caa5e 100644
--- a/bindings/Python/Generated/Frontend/ConditionalMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/ConditionalMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -299,7 +298,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/DefineMacroDirective.cpp b/bindings/Python/Generated/Frontend/DefineMacroDirective.cpp
index 7476d192c..c6a5d6665 100644
--- a/bindings/Python/Generated/Frontend/DefineMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/DefineMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -358,7 +357,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/ElseIfDefinedMacroDirective.cpp b/bindings/Python/Generated/Frontend/ElseIfDefinedMacroDirective.cpp
index 8d3d87e8f..87292d4f2 100644
--- a/bindings/Python/Generated/Frontend/ElseIfDefinedMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/ElseIfDefinedMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/ElseIfMacroDirective.cpp b/bindings/Python/Generated/Frontend/ElseIfMacroDirective.cpp
index 3c595457b..29e8e408d 100644
--- a/bindings/Python/Generated/Frontend/ElseIfMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/ElseIfMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/ElseIfNotDefinedMacroDirective.cpp b/bindings/Python/Generated/Frontend/ElseIfNotDefinedMacroDirective.cpp
index a3c50a5cf..37da5a1e6 100644
--- a/bindings/Python/Generated/Frontend/ElseIfNotDefinedMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/ElseIfNotDefinedMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/ElseMacroDirective.cpp b/bindings/Python/Generated/Frontend/ElseMacroDirective.cpp
index 4c48721c6..9f0b264e8 100644
--- a/bindings/Python/Generated/Frontend/ElseMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/ElseMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/EmptyTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/EmptyTokenTreeNode.cpp
index a35305f87..e0b9887ed 100644
--- a/bindings/Python/Generated/Frontend/EmptyTokenTreeNode.cpp
+++ b/bindings/Python/Generated/Frontend/EmptyTokenTreeNode.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/EndIfMacroDirective.cpp b/bindings/Python/Generated/Frontend/EndIfMacroDirective.cpp
index 042c7df66..96e0a98ef 100644
--- a/bindings/Python/Generated/Frontend/EndIfMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/EndIfMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/File.cpp b/bindings/Python/Generated/Frontend/File.cpp
index b205e6a42..ec26f8698 100644
--- a/bindings/Python/Generated/Frontend/File.cpp
+++ b/bindings/Python/Generated/Frontend/File.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -278,14 +277,6 @@ static PyMethodDef gMethods[] = {
 
             return ::mx::to_python(T::containing(arg_0.value()));
           }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::containing(arg_0.value()));
-          }
           while (num_args == 1) {
             auto arg_0 = ::mx::from_python<mx::Token>(args[0]);
             if (!arg_0.has_value()) {
@@ -311,7 +302,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::containing(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -332,7 +323,7 @@ static PyMethodDef gMethods[] = {
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/IfDefinedMacroDirective.cpp b/bindings/Python/Generated/Frontend/IfDefinedMacroDirective.cpp
index d931763c2..6716f07a5 100644
--- a/bindings/Python/Generated/Frontend/IfDefinedMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/IfDefinedMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/IfMacroDirective.cpp b/bindings/Python/Generated/Frontend/IfMacroDirective.cpp
index 5c4751382..7cf648e19 100644
--- a/bindings/Python/Generated/Frontend/IfMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/IfMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/IfNotDefinedMacroDirective.cpp b/bindings/Python/Generated/Frontend/IfNotDefinedMacroDirective.cpp
index f2f1c1293..86ee7c719 100644
--- a/bindings/Python/Generated/Frontend/IfNotDefinedMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/IfNotDefinedMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/ImportMacroDirective.cpp b/bindings/Python/Generated/Frontend/ImportMacroDirective.cpp
index 79f9fec62..9489a12a9 100644
--- a/bindings/Python/Generated/Frontend/ImportMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/ImportMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/IncludeLikeMacroDirective.cpp b/bindings/Python/Generated/Frontend/IncludeLikeMacroDirective.cpp
index 9ae031043..7141f9d26 100644
--- a/bindings/Python/Generated/Frontend/IncludeLikeMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/IncludeLikeMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -293,7 +292,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/IncludeMacroDirective.cpp b/bindings/Python/Generated/Frontend/IncludeMacroDirective.cpp
index c4bda25e7..e58ffc7f8 100644
--- a/bindings/Python/Generated/Frontend/IncludeMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/IncludeMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/IncludeMacrosMacroDirective.cpp b/bindings/Python/Generated/Frontend/IncludeMacrosMacroDirective.cpp
index ccca834e4..7a26deb67 100644
--- a/bindings/Python/Generated/Frontend/IncludeMacrosMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/IncludeMacrosMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/IncludeNextMacroDirective.cpp b/bindings/Python/Generated/Frontend/IncludeNextMacroDirective.cpp
index 9fac06135..6bcd17fc5 100644
--- a/bindings/Python/Generated/Frontend/IncludeNextMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/IncludeNextMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/Macro.cpp b/bindings/Python/Generated/Frontend/Macro.cpp
index 62f9e1890..92a2f23fb 100644
--- a/bindings/Python/Generated/Frontend/Macro.cpp
+++ b/bindings/Python/Generated/Frontend/Macro.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -489,7 +488,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroArgument.cpp b/bindings/Python/Generated/Frontend/MacroArgument.cpp
index 3dc99f917..8a942eea6 100644
--- a/bindings/Python/Generated/Frontend/MacroArgument.cpp
+++ b/bindings/Python/Generated/Frontend/MacroArgument.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -308,7 +307,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroConcatenate.cpp b/bindings/Python/Generated/Frontend/MacroConcatenate.cpp
index eed403bbd..c5df1e553 100644
--- a/bindings/Python/Generated/Frontend/MacroConcatenate.cpp
+++ b/bindings/Python/Generated/Frontend/MacroConcatenate.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -298,7 +297,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroDirective.cpp b/bindings/Python/Generated/Frontend/MacroDirective.cpp
index 66e09d82d..b093446e8 100644
--- a/bindings/Python/Generated/Frontend/MacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/MacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -351,7 +350,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroExpansion.cpp b/bindings/Python/Generated/Frontend/MacroExpansion.cpp
index 8d0fa0971..6d677fb8f 100644
--- a/bindings/Python/Generated/Frontend/MacroExpansion.cpp
+++ b/bindings/Python/Generated/Frontend/MacroExpansion.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -328,7 +327,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroParameter.cpp b/bindings/Python/Generated/Frontend/MacroParameter.cpp
index 9b8ef9e55..9a6ce867e 100644
--- a/bindings/Python/Generated/Frontend/MacroParameter.cpp
+++ b/bindings/Python/Generated/Frontend/MacroParameter.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -318,7 +317,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroParameterSubstitution.cpp b/bindings/Python/Generated/Frontend/MacroParameterSubstitution.cpp
index 733874db4..36acb7397 100644
--- a/bindings/Python/Generated/Frontend/MacroParameterSubstitution.cpp
+++ b/bindings/Python/Generated/Frontend/MacroParameterSubstitution.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -308,7 +307,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroStringify.cpp b/bindings/Python/Generated/Frontend/MacroStringify.cpp
index 9f8db2708..799d9989d 100644
--- a/bindings/Python/Generated/Frontend/MacroStringify.cpp
+++ b/bindings/Python/Generated/Frontend/MacroStringify.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -298,7 +297,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroSubstitution.cpp b/bindings/Python/Generated/Frontend/MacroSubstitution.cpp
index ae889f9b1..227bcc50a 100644
--- a/bindings/Python/Generated/Frontend/MacroSubstitution.cpp
+++ b/bindings/Python/Generated/Frontend/MacroSubstitution.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -354,7 +353,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroVAOpt.cpp b/bindings/Python/Generated/Frontend/MacroVAOpt.cpp
index 4d358b4a2..64a3e0e2b 100644
--- a/bindings/Python/Generated/Frontend/MacroVAOpt.cpp
+++ b/bindings/Python/Generated/Frontend/MacroVAOpt.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -298,7 +297,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/MacroVAOptArgument.cpp b/bindings/Python/Generated/Frontend/MacroVAOptArgument.cpp
index 78e1bd8ad..1e6d7b2aa 100644
--- a/bindings/Python/Generated/Frontend/MacroVAOptArgument.cpp
+++ b/bindings/Python/Generated/Frontend/MacroVAOptArgument.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/OtherMacroDirective.cpp b/bindings/Python/Generated/Frontend/OtherMacroDirective.cpp
index 5e2f42f10..bd5c5819d 100644
--- a/bindings/Python/Generated/Frontend/OtherMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/OtherMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/PragmaMacroDirective.cpp b/bindings/Python/Generated/Frontend/PragmaMacroDirective.cpp
index 7263de10c..2b501e256 100644
--- a/bindings/Python/Generated/Frontend/PragmaMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/PragmaMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/RegexQueryMatch.cpp b/bindings/Python/Generated/Frontend/RegexQueryMatch.cpp
index 01edaf3eb..cd69a50af 100644
--- a/bindings/Python/Generated/Frontend/RegexQueryMatch.cpp
+++ b/bindings/Python/Generated/Frontend/RegexQueryMatch.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/SequenceTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/SequenceTokenTreeNode.cpp
index 10ce5cbe7..5814eb398 100644
--- a/bindings/Python/Generated/Frontend/SequenceTokenTreeNode.cpp
+++ b/bindings/Python/Generated/Frontend/SequenceTokenTreeNode.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/SubstitutionTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/SubstitutionTokenTreeNode.cpp
index 5f038ca23..16b5aba55 100644
--- a/bindings/Python/Generated/Frontend/SubstitutionTokenTreeNode.cpp
+++ b/bindings/Python/Generated/Frontend/SubstitutionTokenTreeNode.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/Token.cpp b/bindings/Python/Generated/Frontend/Token.cpp
index bd279cf9a..7827f8efe 100644
--- a/bindings/Python/Generated/Frontend/Token.cpp
+++ b/bindings/Python/Generated/Frontend/Token.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -243,7 +242,7 @@ static PyMethodDef gMethods[] = {
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -281,7 +280,7 @@ static PyMethodDef gMethods[] = {
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/Frontend/TokenContext.cpp b/bindings/Python/Generated/Frontend/TokenContext.cpp
index 5aab640d6..7a6a72b2f 100644
--- a/bindings/Python/Generated/Frontend/TokenContext.cpp
+++ b/bindings/Python/Generated/Frontend/TokenContext.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/TokenRange.cpp b/bindings/Python/Generated/Frontend/TokenRange.cpp
index 491e82eda..0d723a281 100644
--- a/bindings/Python/Generated/Frontend/TokenRange.cpp
+++ b/bindings/Python/Generated/Frontend/TokenRange.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/TokenTokenTreeNode.cpp b/bindings/Python/Generated/Frontend/TokenTokenTreeNode.cpp
index e8e63f8ec..bcf2f4aef 100644
--- a/bindings/Python/Generated/Frontend/TokenTokenTreeNode.cpp
+++ b/bindings/Python/Generated/Frontend/TokenTokenTreeNode.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/TokenTree.cpp b/bindings/Python/Generated/Frontend/TokenTree.cpp
index 875c9d078..f843cc667 100644
--- a/bindings/Python/Generated/Frontend/TokenTree.cpp
+++ b/bindings/Python/Generated/Frontend/TokenTree.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/TokenTreeNode.cpp b/bindings/Python/Generated/Frontend/TokenTreeNode.cpp
index 818fa757c..82372d06d 100644
--- a/bindings/Python/Generated/Frontend/TokenTreeNode.cpp
+++ b/bindings/Python/Generated/Frontend/TokenTreeNode.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/Frontend/UndefineMacroDirective.cpp b/bindings/Python/Generated/Frontend/UndefineMacroDirective.cpp
index 3b33dec72..09e1bd5c3 100644
--- a/bindings/Python/Generated/Frontend/UndefineMacroDirective.cpp
+++ b/bindings/Python/Generated/Frontend/UndefineMacroDirective.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -288,7 +287,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::from(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/IR/ABI/CallArgsOp.cpp b/bindings/Python/Generated/IR/ABI/CallArgsOp.cpp
deleted file mode 100644
index f33713b9f..000000000
--- a/bindings/Python/Generated/IR/ABI/CallArgsOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::CallArgsOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1284]) || tp >= &(gTypes[1285])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::CallArgsOp::static_kind():
-      tp = &(gTypes[1284]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CallArgsOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallArgsOp::results"),
-    nullptr,
-  },
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallArgsOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallArgsOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallArgsOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallArgsOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1284]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.CallArgsOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::CallArgsOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CallArgsOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CallArgsOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CallArgsOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/CallExecutionOp.cpp b/bindings/Python/Generated/IR/ABI/CallExecutionOp.cpp
deleted file mode 100644
index 5cbe6a7bf..000000000
--- a/bindings/Python/Generated/IR/ABI/CallExecutionOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::CallExecutionOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1285]) || tp >= &(gTypes[1286])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::CallExecutionOp::static_kind():
-      tp = &(gTypes[1285]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CallExecutionOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "arguments",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arguments);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallExecutionOp::arguments"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallExecutionOp::result"),
-    nullptr,
-  },
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallExecutionOp::body"),
-    nullptr,
-  },
-  {
-    "arg_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arg_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallExecutionOp::arg_operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallExecutionOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallExecutionOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallExecutionOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1285]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.CallExecutionOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::CallExecutionOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CallExecutionOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CallExecutionOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CallExecutionOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/CallOp.cpp b/bindings/Python/Generated/IR/ABI/CallOp.cpp
deleted file mode 100644
index a02007c9e..000000000
--- a/bindings/Python/Generated/IR/ABI/CallOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::CallOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1286]) || tp >= &(gTypes[1287])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::CallOp::static_kind():
-      tp = &(gTypes[1286]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CallOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "arguments",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arguments);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallOp::arguments"),
-    nullptr,
-  },
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallOp::results"),
-    nullptr,
-  },
-  {
-    "callee",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->callee());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallOp::callee"),
-    nullptr,
-  },
-  {
-    "arg_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arg_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallOp::arg_operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1286]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.CallOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::CallOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CallOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CallOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CallOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/CallRetsOp.cpp b/bindings/Python/Generated/IR/ABI/CallRetsOp.cpp
deleted file mode 100644
index 4f2aa7464..000000000
--- a/bindings/Python/Generated/IR/ABI/CallRetsOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::CallRetsOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1287]) || tp >= &(gTypes[1288])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::CallRetsOp::static_kind():
-      tp = &(gTypes[1287]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CallRetsOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallRetsOp::results"),
-    nullptr,
-  },
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallRetsOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallRetsOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallRetsOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::CallRetsOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1287]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.CallRetsOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::CallRetsOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CallRetsOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CallRetsOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CallRetsOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/DirectOp.cpp b/bindings/Python/Generated/IR/ABI/DirectOp.cpp
deleted file mode 100644
index 4d5a5f5ac..000000000
--- a/bindings/Python/Generated/IR/ABI/DirectOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::DirectOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1288]) || tp >= &(gTypes[1289])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::DirectOp::static_kind():
-      tp = &(gTypes[1288]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DirectOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::value);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::DirectOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::result);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::DirectOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::DirectOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::DirectOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::DirectOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1288]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.DirectOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::DirectOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DirectOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DirectOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DirectOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/EpilogueOp.cpp b/bindings/Python/Generated/IR/ABI/EpilogueOp.cpp
deleted file mode 100644
index 5104716db..000000000
--- a/bindings/Python/Generated/IR/ABI/EpilogueOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::EpilogueOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1289]) || tp >= &(gTypes[1290])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::EpilogueOp::static_kind():
-      tp = &(gTypes[1289]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "EpilogueOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::EpilogueOp::results"),
-    nullptr,
-  },
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::EpilogueOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::EpilogueOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::EpilogueOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::EpilogueOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1289]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.EpilogueOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::EpilogueOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'EpilogueOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'EpilogueOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'EpilogueOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/FuncOp.cpp b/bindings/Python/Generated/IR/ABI/FuncOp.cpp
deleted file mode 100644
index a8ba132e7..000000000
--- a/bindings/Python/Generated/IR/ABI/FuncOp.cpp
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::FuncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1290]) || tp >= &(gTypes[1291])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::FuncOp::static_kind():
-      tp = &(gTypes[1290]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FuncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::body"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::name"),
-    nullptr,
-  },
-  {
-    "function_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->function_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::function_type"),
-    nullptr,
-  },
-  {
-    "visibility",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->visibility());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::visibility"),
-    nullptr,
-  },
-  {
-    "is_var_arg",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_var_arg());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::is_var_arg"),
-    nullptr,
-  },
-  {
-    "callable_results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::callable_results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::callable_results"),
-    nullptr,
-  },
-  {
-    "argument_types",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::argument_types);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::argument_types"),
-    nullptr,
-  },
-  {
-    "result_types",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::result_types);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::result_types"),
-    nullptr,
-  },
-  {
-    "is_declaration",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_declaration());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::is_declaration"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::FuncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1290]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.FuncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::FuncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FuncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FuncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FuncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/IndirectOp.cpp b/bindings/Python/Generated/IR/ABI/IndirectOp.cpp
deleted file mode 100644
index 504cdea4f..000000000
--- a/bindings/Python/Generated/IR/ABI/IndirectOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::IndirectOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1291]) || tp >= &(gTypes[1292])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::IndirectOp::static_kind():
-      tp = &(gTypes[1291]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IndirectOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::IndirectOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::IndirectOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::IndirectOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::IndirectOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::IndirectOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1291]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.IndirectOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::IndirectOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IndirectOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IndirectOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IndirectOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/Operation.cpp b/bindings/Python/Generated/IR/ABI/Operation.cpp
deleted file mode 100644
index 452815a73..000000000
--- a/bindings/Python/Generated/IR/ABI/Operation.cpp
+++ /dev/null
@@ -1,257 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::Operation;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1283]) || tp >= &(gTypes[1295])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::CallArgsOp::static_kind():
-      tp = &(gTypes[1284]);
-      break;
-
-    case mx::ir::abi::CallExecutionOp::static_kind():
-      tp = &(gTypes[1285]);
-      break;
-
-    case mx::ir::abi::CallOp::static_kind():
-      tp = &(gTypes[1286]);
-      break;
-
-    case mx::ir::abi::CallRetsOp::static_kind():
-      tp = &(gTypes[1287]);
-      break;
-
-    case mx::ir::abi::DirectOp::static_kind():
-      tp = &(gTypes[1288]);
-      break;
-
-    case mx::ir::abi::EpilogueOp::static_kind():
-      tp = &(gTypes[1289]);
-      break;
-
-    case mx::ir::abi::FuncOp::static_kind():
-      tp = &(gTypes[1290]);
-      break;
-
-    case mx::ir::abi::IndirectOp::static_kind():
-      tp = &(gTypes[1291]);
-      break;
-
-    case mx::ir::abi::PrologueOp::static_kind():
-      tp = &(gTypes[1292]);
-      break;
-
-    case mx::ir::abi::RetDirectOp::static_kind():
-      tp = &(gTypes[1293]);
-      break;
-
-    case mx::ir::abi::YieldOp::static_kind():
-      tp = &(gTypes[1294]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operation", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::Operation::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1283]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.Operation";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::Operation");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[998].tp_hash;
-  tp->tp_richcompare = gTypes[998].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[998]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operation.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operation.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operation' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/PrologueOp.cpp b/bindings/Python/Generated/IR/ABI/PrologueOp.cpp
deleted file mode 100644
index 8eeca8148..000000000
--- a/bindings/Python/Generated/IR/ABI/PrologueOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::PrologueOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1292]) || tp >= &(gTypes[1293])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::PrologueOp::static_kind():
-      tp = &(gTypes[1292]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PrologueOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::PrologueOp::results"),
-    nullptr,
-  },
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::PrologueOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::PrologueOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::PrologueOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::PrologueOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1292]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.PrologueOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::PrologueOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PrologueOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PrologueOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PrologueOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/RetDirectOp.cpp b/bindings/Python/Generated/IR/ABI/RetDirectOp.cpp
deleted file mode 100644
index 81eb8a349..000000000
--- a/bindings/Python/Generated/IR/ABI/RetDirectOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::RetDirectOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1293]) || tp >= &(gTypes[1294])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::RetDirectOp::static_kind():
-      tp = &(gTypes[1293]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RetDirectOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::RetDirectOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::result);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::RetDirectOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::RetDirectOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::RetDirectOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::RetDirectOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1293]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.RetDirectOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::RetDirectOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RetDirectOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RetDirectOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RetDirectOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ABI/YieldOp.cpp b/bindings/Python/Generated/IR/ABI/YieldOp.cpp
deleted file mode 100644
index 1c3b99655..000000000
--- a/bindings/Python/Generated/IR/ABI/YieldOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::abi::YieldOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1294]) || tp >= &(gTypes[1295])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::abi::YieldOp::static_kind():
-      tp = &(gTypes[1294]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "YieldOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "values",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::values);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::YieldOp::values"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::result);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::abi::YieldOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::YieldOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::YieldOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::abi::YieldOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1294]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.abi.YieldOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::abi::::YieldOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1283].tp_hash;
-  tp->tp_richcompare = gTypes[1283].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1283]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'YieldOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'YieldOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'YieldOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Argument.cpp b/bindings/Python/Generated/IR/Argument.cpp
deleted file mode 100644
index 39747c020..000000000
--- a/bindings/Python/Generated/IR/Argument.cpp
+++ /dev/null
@@ -1,270 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Block.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Argument;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[994]) || tp >= &(gTypes[995])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::Argument::static_kind():
-      tp = &(gTypes[994]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Argument", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "index",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->index());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Argument::index"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Argument::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Argument::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[994]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Argument";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Argument");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[993].tp_hash;
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[993]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Argument.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Argument.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Argument' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Attribute.cpp b/bindings/Python/Generated/IR/Attribute.cpp
deleted file mode 100644
index 8a544e859..000000000
--- a/bindings/Python/Generated/IR/Attribute.cpp
+++ /dev/null
@@ -1,710 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Attribute;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[867]) || tp >= &(gTypes[993])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::TypedAttr::static_kind():
-      tp = &(gTypes[869]);
-      break;
-
-    case mx::ir::builtin::ElementsAttr::static_kind():
-      tp = &(gTypes[870]);
-      break;
-
-    case mx::ir::builtin::AffineMapAttr::static_kind():
-      tp = &(gTypes[871]);
-      break;
-
-    case mx::ir::builtin::ArrayAttr::static_kind():
-      tp = &(gTypes[872]);
-      break;
-
-    case mx::ir::builtin::DenseArrayAttr::static_kind():
-      tp = &(gTypes[873]);
-      break;
-
-    case mx::ir::builtin::DenseIntOrFPElementsAttr::static_kind():
-      tp = &(gTypes[874]);
-      break;
-
-    case mx::ir::builtin::DenseStringElementsAttr::static_kind():
-      tp = &(gTypes[875]);
-      break;
-
-    case mx::ir::builtin::DenseResourceElementsAttr::static_kind():
-      tp = &(gTypes[876]);
-      break;
-
-    case mx::ir::builtin::DictionaryAttr::static_kind():
-      tp = &(gTypes[877]);
-      break;
-
-    case mx::ir::builtin::FloatAttr::static_kind():
-      tp = &(gTypes[878]);
-      break;
-
-    case mx::ir::builtin::IntegerAttr::static_kind():
-      tp = &(gTypes[879]);
-      break;
-
-    case mx::ir::builtin::IntegerSetAttr::static_kind():
-      tp = &(gTypes[880]);
-      break;
-
-    case mx::ir::builtin::OpaqueAttr::static_kind():
-      tp = &(gTypes[881]);
-      break;
-
-    case mx::ir::builtin::SparseElementsAttr::static_kind():
-      tp = &(gTypes[882]);
-      break;
-
-    case mx::ir::builtin::StridedLayoutAttr::static_kind():
-      tp = &(gTypes[883]);
-      break;
-
-    case mx::ir::builtin::StringAttr::static_kind():
-      tp = &(gTypes[884]);
-      break;
-
-    case mx::ir::builtin::SymbolRefAttr::static_kind():
-      tp = &(gTypes[885]);
-      break;
-
-    case mx::ir::builtin::TypeAttr::static_kind():
-      tp = &(gTypes[886]);
-      break;
-
-    case mx::ir::builtin::UnitAttr::static_kind():
-      tp = &(gTypes[887]);
-      break;
-
-    case mx::ir::builtin::BoolAttr::static_kind():
-      tp = &(gTypes[888]);
-      break;
-
-    case mx::ir::builtin::FlatSymbolRefAttr::static_kind():
-      tp = &(gTypes[889]);
-      break;
-
-    case mx::ir::builtin::DenseIntElementsAttr::static_kind():
-      tp = &(gTypes[890]);
-      break;
-
-    case mx::ir::builtin::DataLayoutSpecAttr::static_kind():
-      tp = &(gTypes[891]);
-      break;
-
-    case mx::ir::llvm::CConvAttr::static_kind():
-      tp = &(gTypes[893]);
-      break;
-
-    case mx::ir::llvm::ComdatAttr::static_kind():
-      tp = &(gTypes[894]);
-      break;
-
-    case mx::ir::llvm::LinkageAttr::static_kind():
-      tp = &(gTypes[895]);
-      break;
-
-    case mx::ir::llvm::FramePointerKindAttr::static_kind():
-      tp = &(gTypes[896]);
-      break;
-
-    case mx::ir::llvm::LoopVectorizeAttr::static_kind():
-      tp = &(gTypes[897]);
-      break;
-
-    case mx::ir::llvm::LoopInterleaveAttr::static_kind():
-      tp = &(gTypes[898]);
-      break;
-
-    case mx::ir::llvm::LoopUnrollAttr::static_kind():
-      tp = &(gTypes[899]);
-      break;
-
-    case mx::ir::llvm::LoopUnrollAndJamAttr::static_kind():
-      tp = &(gTypes[900]);
-      break;
-
-    case mx::ir::llvm::LoopLICMAttr::static_kind():
-      tp = &(gTypes[901]);
-      break;
-
-    case mx::ir::llvm::LoopDistributeAttr::static_kind():
-      tp = &(gTypes[902]);
-      break;
-
-    case mx::ir::llvm::LoopPipelineAttr::static_kind():
-      tp = &(gTypes[903]);
-      break;
-
-    case mx::ir::llvm::LoopPeeledAttr::static_kind():
-      tp = &(gTypes[904]);
-      break;
-
-    case mx::ir::llvm::LoopUnswitchAttr::static_kind():
-      tp = &(gTypes[905]);
-      break;
-
-    case mx::ir::llvm::LoopAnnotationAttr::static_kind():
-      tp = &(gTypes[906]);
-      break;
-
-    case mx::ir::llvm::DIExpressionElemAttr::static_kind():
-      tp = &(gTypes[907]);
-      break;
-
-    case mx::ir::llvm::DIExpressionAttr::static_kind():
-      tp = &(gTypes[908]);
-      break;
-
-    case mx::ir::llvm::DINullTypeAttr::static_kind():
-      tp = &(gTypes[909]);
-      break;
-
-    case mx::ir::llvm::DIBasicTypeAttr::static_kind():
-      tp = &(gTypes[910]);
-      break;
-
-    case mx::ir::llvm::DICompileUnitAttr::static_kind():
-      tp = &(gTypes[911]);
-      break;
-
-    case mx::ir::llvm::DICompositeTypeAttr::static_kind():
-      tp = &(gTypes[912]);
-      break;
-
-    case mx::ir::llvm::DIDerivedTypeAttr::static_kind():
-      tp = &(gTypes[913]);
-      break;
-
-    case mx::ir::llvm::DIFileAttr::static_kind():
-      tp = &(gTypes[914]);
-      break;
-
-    case mx::ir::llvm::DIGlobalVariableExpressionAttr::static_kind():
-      tp = &(gTypes[915]);
-      break;
-
-    case mx::ir::llvm::DIGlobalVariableAttr::static_kind():
-      tp = &(gTypes[916]);
-      break;
-
-    case mx::ir::llvm::DILexicalBlockAttr::static_kind():
-      tp = &(gTypes[917]);
-      break;
-
-    case mx::ir::llvm::DILexicalBlockFileAttr::static_kind():
-      tp = &(gTypes[918]);
-      break;
-
-    case mx::ir::llvm::DILocalVariableAttr::static_kind():
-      tp = &(gTypes[919]);
-      break;
-
-    case mx::ir::llvm::DISubprogramAttr::static_kind():
-      tp = &(gTypes[920]);
-      break;
-
-    case mx::ir::llvm::DIModuleAttr::static_kind():
-      tp = &(gTypes[921]);
-      break;
-
-    case mx::ir::llvm::DINamespaceAttr::static_kind():
-      tp = &(gTypes[922]);
-      break;
-
-    case mx::ir::llvm::DISubrangeAttr::static_kind():
-      tp = &(gTypes[923]);
-      break;
-
-    case mx::ir::llvm::DISubroutineTypeAttr::static_kind():
-      tp = &(gTypes[924]);
-      break;
-
-    case mx::ir::llvm::DILabelAttr::static_kind():
-      tp = &(gTypes[925]);
-      break;
-
-    case mx::ir::llvm::MemoryEffectsAttr::static_kind():
-      tp = &(gTypes[926]);
-      break;
-
-    case mx::ir::llvm::AliasScopeDomainAttr::static_kind():
-      tp = &(gTypes[927]);
-      break;
-
-    case mx::ir::llvm::AliasScopeAttr::static_kind():
-      tp = &(gTypes[928]);
-      break;
-
-    case mx::ir::llvm::AccessGroupAttr::static_kind():
-      tp = &(gTypes[929]);
-      break;
-
-    case mx::ir::llvm::TBAARootAttr::static_kind():
-      tp = &(gTypes[930]);
-      break;
-
-    case mx::ir::llvm::TBAAMemberAttr::static_kind():
-      tp = &(gTypes[931]);
-      break;
-
-    case mx::ir::llvm::TBAATypeDescriptorAttr::static_kind():
-      tp = &(gTypes[932]);
-      break;
-
-    case mx::ir::llvm::TBAATagAttr::static_kind():
-      tp = &(gTypes[933]);
-      break;
-
-    case mx::ir::llvm::VScaleRangeAttr::static_kind():
-      tp = &(gTypes[934]);
-      break;
-
-    case mx::ir::llvm::TargetFeaturesAttr::static_kind():
-      tp = &(gTypes[935]);
-      break;
-
-    case mx::ir::llvm::IntegerOverflowFlagsAttr::static_kind():
-      tp = &(gTypes[936]);
-      break;
-
-    case mx::ir::llvm::FastmathFlagsAttr::static_kind():
-      tp = &(gTypes[937]);
-      break;
-
-    case mx::ir::hl::AnnotationAttr::static_kind():
-      tp = &(gTypes[939]);
-      break;
-
-    case mx::ir::hl::FormatAttr::static_kind():
-      tp = &(gTypes[940]);
-      break;
-
-    case mx::ir::hl::SectionAttr::static_kind():
-      tp = &(gTypes[941]);
-      break;
-
-    case mx::ir::hl::AliasAttr::static_kind():
-      tp = &(gTypes[942]);
-      break;
-
-    case mx::ir::hl::ErrorAttr::static_kind():
-      tp = &(gTypes[943]);
-      break;
-
-    case mx::ir::hl::CountedByAttr::static_kind():
-      tp = &(gTypes[944]);
-      break;
-
-    case mx::ir::hl::CleanupAttr::static_kind():
-      tp = &(gTypes[945]);
-      break;
-
-    case mx::ir::hl::AlignedAttr::static_kind():
-      tp = &(gTypes[946]);
-      break;
-
-    case mx::ir::hl::AlwaysInlineAttr::static_kind():
-      tp = &(gTypes[947]);
-      break;
-
-    case mx::ir::hl::NoInlineAttr::static_kind():
-      tp = &(gTypes[948]);
-      break;
-
-    case mx::ir::hl::ConstAttr::static_kind():
-      tp = &(gTypes[949]);
-      break;
-
-    case mx::ir::hl::LoaderUninitializedAttr::static_kind():
-      tp = &(gTypes[950]);
-      break;
-
-    case mx::ir::hl::NoInstrumentFunctionAttr::static_kind():
-      tp = &(gTypes[951]);
-      break;
-
-    case mx::ir::hl::PackedAttr::static_kind():
-      tp = &(gTypes[952]);
-      break;
-
-    case mx::ir::hl::PureAttr::static_kind():
-      tp = &(gTypes[953]);
-      break;
-
-    case mx::ir::hl::WarnUnusedResultAttr::static_kind():
-      tp = &(gTypes[954]);
-      break;
-
-    case mx::ir::hl::RestrictAttr::static_kind():
-      tp = &(gTypes[955]);
-      break;
-
-    case mx::ir::hl::NoThrowAttr::static_kind():
-      tp = &(gTypes[956]);
-      break;
-
-    case mx::ir::hl::NonNullAttr::static_kind():
-      tp = &(gTypes[957]);
-      break;
-
-    case mx::ir::hl::LeafAttr::static_kind():
-      tp = &(gTypes[958]);
-      break;
-
-    case mx::ir::hl::ColdAttr::static_kind():
-      tp = &(gTypes[959]);
-      break;
-
-    case mx::ir::hl::TransparentUnionAttr::static_kind():
-      tp = &(gTypes[960]);
-      break;
-
-    case mx::ir::hl::ReturnsTwiceAttr::static_kind():
-      tp = &(gTypes[961]);
-      break;
-
-    case mx::ir::hl::MayAliasAttr::static_kind():
-      tp = &(gTypes[962]);
-      break;
-
-    case mx::ir::hl::UnusedAttr::static_kind():
-      tp = &(gTypes[963]);
-      break;
-
-    case mx::ir::hl::UsedAttr::static_kind():
-      tp = &(gTypes[964]);
-      break;
-
-    case mx::ir::hl::GNUInlineAttr::static_kind():
-      tp = &(gTypes[965]);
-      break;
-
-    case mx::ir::hl::NoCfCheckAttr::static_kind():
-      tp = &(gTypes[966]);
-      break;
-
-    case mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr::static_kind():
-      tp = &(gTypes[967]);
-      break;
-
-    case mx::ir::hl::AvailabilityAttrAttr::static_kind():
-      tp = &(gTypes[968]);
-      break;
-
-    case mx::ir::hl::FallthroughAttr::static_kind():
-      tp = &(gTypes[969]);
-      break;
-
-    case mx::ir::hl::NoProfileInstrumentFunctionAttr::static_kind():
-      tp = &(gTypes[970]);
-      break;
-
-    case mx::ir::hl::AsmLabelAttr::static_kind():
-      tp = &(gTypes[971]);
-      break;
-
-    case mx::ir::hl::ModeAttr::static_kind():
-      tp = &(gTypes[972]);
-      break;
-
-    case mx::ir::hl::BuiltinAttr::static_kind():
-      tp = &(gTypes[973]);
-      break;
-
-    case mx::ir::hl::AllocAlignAttr::static_kind():
-      tp = &(gTypes[974]);
-      break;
-
-    case mx::ir::hl::AllocSizeAttr::static_kind():
-      tp = &(gTypes[975]);
-      break;
-
-    case mx::ir::hl::DeprecatedAttr::static_kind():
-      tp = &(gTypes[976]);
-      break;
-
-    case mx::ir::hl::MaxFieldAlignmentAttr::static_kind():
-      tp = &(gTypes[977]);
-      break;
-
-    case mx::ir::hl::VisibilityAttr::static_kind():
-      tp = &(gTypes[978]);
-      break;
-
-    case mx::ir::hl::AssumeAlignedAttr::static_kind():
-      tp = &(gTypes[979]);
-      break;
-
-    case mx::ir::hl::CVQualifiersAttr::static_kind():
-      tp = &(gTypes[980]);
-      break;
-
-    case mx::ir::hl::UCVQualifiersAttr::static_kind():
-      tp = &(gTypes[981]);
-      break;
-
-    case mx::ir::hl::CVRQualifiersAttr::static_kind():
-      tp = &(gTypes[982]);
-      break;
-
-    case mx::ir::hl::OffsetOfNodeAttr::static_kind():
-      tp = &(gTypes[983]);
-      break;
-
-    case mx::ir::core::BooleanAttr::static_kind():
-      tp = &(gTypes[985]);
-      break;
-
-    case mx::ir::core::IntegerAttr::static_kind():
-      tp = &(gTypes[986]);
-      break;
-
-    case mx::ir::core::FloatAttr::static_kind():
-      tp = &(gTypes[987]);
-      break;
-
-    case mx::ir::core::VoidAttr::static_kind():
-      tp = &(gTypes[988]);
-      break;
-
-    case mx::ir::core::SourceLanguageAttr::static_kind():
-      tp = &(gTypes[989]);
-      break;
-
-    case mx::ir::core::GlobalLinkageKindAttr::static_kind():
-      tp = &(gTypes[990]);
-      break;
-
-    case mx::ir::meta::IdentifierAttr::static_kind():
-      tp = &(gTypes[992]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Attribute", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "kind",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->kind());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Attribute::kind"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[867]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Attribute";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Attribute");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t {
-    return static_cast<Py_hash_t>(reinterpret_cast<uintptr_t>(T_cast(obj)->underlying_attribute()));
-  };
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = nullptr;
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Attribute.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Attribute.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Attribute' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/AttributeKind.cpp b/bindings/Python/Generated/IR/AttributeKind.cpp
deleted file mode 100644
index d1ebb3cac..000000000
--- a/bindings/Python/Generated/IR/AttributeKind.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/AttributeKind.h>
-#include <multiplier/Iterator.h>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-namespace mx {
-namespace {
-using T = mx::ir::AttributeKind;
-}  // namespace
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  return PyObject_GetAttrString(reinterpret_cast<BorrowedPyObject *>(gType),
-                                EnumeratorName(val));
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  if (Py_TYPE(obj) != gType) {
-    return std::nullopt;
-  }
-
-  SharedPyPtr long_val(PyObject_GetAttrString(obj, "value"));
-  if (!long_val) {
-    PyErr_Clear();
-    return std::nullopt;
-  }
-
-  if (!PyLong_Check(long_val.Get())) {
-    return std::nullopt;
-  }
-
-  int did_overflow = 0;
-  const auto ret = static_cast<T>(
-      PyLong_AsLongLongAndOverflow(long_val.Get(), &did_overflow));
-  if (did_overflow) {
-    return std::nullopt;
-  }
-
-  return ret;
-}
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  const char * const enum_name = EnumerationName(T{});
-  bool created = false;
-
-  if (!gType) {
-    SharedPyPtr enum_module(PyImport_ImportModule("enum"));
-    if (!enum_module) {
-      return false;
-    }
-
-    SharedPyPtr int_enum(PyObject_GetAttrString(enum_module.Get(), "IntEnum"));
-    if (!int_enum) {
-      return false;
-    }
-
-    SharedPyPtr enum_meta(PyObject_Type(int_enum.Get()));
-    SharedPyPtr prepare(PyObject_GetAttrString(enum_meta.Get(), "__prepare__"));
-    if (!prepare) {
-      return false;
-    }
-
-    // Get the `enum._EnumDict` for what we're making.
-    SharedPyPtr ns_dict(PyObject_CallFunction(prepare.Get(), "s(O)", enum_name, int_enum.Get()));
-    if (!ns_dict) {
-      return false;
-    }
-
-    // Assign each enumerator.
-    for (T val : EnumerationRange<T>()) {
-      auto ival = PyLong_FromUnsignedLongLong(static_cast<uint64_t>(val));
-      if (ival) {
-        auto iname = PyUnicode_FromString(EnumeratorName(val));
-        if (!PyObject_SetItem(ns_dict, iname, ival)) {
-          continue;
-        }
-
-        Py_DECREF(iname);
-        Py_DECREF(ival);
-      }
-      return false;
-    }
-
-    // Create the type.
-    auto enum_class = PyObject_CallFunction(
-        enum_meta.Get(), "s(O)O", enum_name, int_enum.Get(), ns_dict.Get());
-    if (!enum_class) {
-      return false;
-    }
-
-    if (!PyType_Check(enum_class)) {
-      Py_DECREF(enum_class);
-
-      PyErrorStreamer(PyExc_ImportError)
-          << "Created enum class for enumerator '" << enum_name
-          << "' is not a python type";
-      return false;
-    }
-
-    gType = reinterpret_cast<PyTypeObject *>(enum_class);
-    created = true;
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, enum_name, tp_obj)) {
-    return false;
-  }
-
-  if (created) {
-    Py_DECREF(tp_obj);
-  }
-
-  return true;
-}
-
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/BasicBlockOrder.cpp b/bindings/Python/Generated/IR/BasicBlockOrder.cpp
deleted file mode 100644
index 6993fbe1f..000000000
--- a/bindings/Python/Generated/IR/BasicBlockOrder.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Region.h>
-#include <multiplier/Iterator.h>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-namespace mx {
-namespace {
-using T = mx::ir::BasicBlockOrder;
-}  // namespace
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  return PyObject_GetAttrString(reinterpret_cast<BorrowedPyObject *>(gType),
-                                EnumeratorName(val));
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  if (Py_TYPE(obj) != gType) {
-    return std::nullopt;
-  }
-
-  SharedPyPtr long_val(PyObject_GetAttrString(obj, "value"));
-  if (!long_val) {
-    PyErr_Clear();
-    return std::nullopt;
-  }
-
-  if (!PyLong_Check(long_val.Get())) {
-    return std::nullopt;
-  }
-
-  int did_overflow = 0;
-  const auto ret = static_cast<T>(
-      PyLong_AsLongLongAndOverflow(long_val.Get(), &did_overflow));
-  if (did_overflow) {
-    return std::nullopt;
-  }
-
-  return ret;
-}
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  const char * const enum_name = EnumerationName(T{});
-  bool created = false;
-
-  if (!gType) {
-    SharedPyPtr enum_module(PyImport_ImportModule("enum"));
-    if (!enum_module) {
-      return false;
-    }
-
-    SharedPyPtr int_enum(PyObject_GetAttrString(enum_module.Get(), "IntEnum"));
-    if (!int_enum) {
-      return false;
-    }
-
-    SharedPyPtr enum_meta(PyObject_Type(int_enum.Get()));
-    SharedPyPtr prepare(PyObject_GetAttrString(enum_meta.Get(), "__prepare__"));
-    if (!prepare) {
-      return false;
-    }
-
-    // Get the `enum._EnumDict` for what we're making.
-    SharedPyPtr ns_dict(PyObject_CallFunction(prepare.Get(), "s(O)", enum_name, int_enum.Get()));
-    if (!ns_dict) {
-      return false;
-    }
-
-    // Assign each enumerator.
-    for (T val : EnumerationRange<T>()) {
-      auto ival = PyLong_FromUnsignedLongLong(static_cast<uint64_t>(val));
-      if (ival) {
-        auto iname = PyUnicode_FromString(EnumeratorName(val));
-        if (!PyObject_SetItem(ns_dict, iname, ival)) {
-          continue;
-        }
-
-        Py_DECREF(iname);
-        Py_DECREF(ival);
-      }
-      return false;
-    }
-
-    // Create the type.
-    auto enum_class = PyObject_CallFunction(
-        enum_meta.Get(), "s(O)O", enum_name, int_enum.Get(), ns_dict.Get());
-    if (!enum_class) {
-      return false;
-    }
-
-    if (!PyType_Check(enum_class)) {
-      Py_DECREF(enum_class);
-
-      PyErrorStreamer(PyExc_ImportError)
-          << "Created enum class for enumerator '" << enum_name
-          << "' is not a python type";
-      return false;
-    }
-
-    gType = reinterpret_cast<PyTypeObject *>(enum_class);
-    created = true;
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, enum_name, tp_obj)) {
-    return false;
-  }
-
-  if (created) {
-    Py_DECREF(tp_obj);
-  }
-
-  return true;
-}
-
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Block.cpp b/bindings/Python/Generated/IR/Block.cpp
deleted file mode 100644
index 14b17f5b0..000000000
--- a/bindings/Python/Generated/IR/Block.cpp
+++ /dev/null
@@ -1,323 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Block.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Block;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[996]) || tp >= &(gTypes[997])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  auto ret = gType->tp_alloc(gType, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Block", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "num_arguments",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_arguments());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Block::num_arguments"),
-    nullptr,
-  },
-  {
-    "arguments",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arguments);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Block::arguments"),
-    nullptr,
-  },
-  {
-    "operations",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::operations);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Block::operations"),
-    nullptr,
-  },
-  {
-    "reverse_operations",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::reverse_operations);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Block::reverse_operations"),
-    nullptr,
-  },
-  {
-    "uses",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::uses);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Block::uses"),
-    nullptr,
-  },
-  {
-    "terminator",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->terminator());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Block::terminator"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "containing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Argument>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::containing(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::containing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'containing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Block::containing"),
-  },
-  {
-    "nth_argument",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          T *obj = T_cast(self);
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<uint32_t>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(obj->nth_argument(std::move(arg_0.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'nth_argument'";
-          return nullptr;
-        }),
-    METH_FASTCALL,
-    PyDoc_STR("Wrapper for mx::ir::Block::nth_argument"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[996]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Block";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Block");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t {
-    return static_cast<Py_hash_t>(reinterpret_cast<uintptr_t>(T_cast(obj)->underlying_block()));
-  };
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = nullptr;
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Block.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Block.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Block' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/AffineMapAttr.cpp b/bindings/Python/Generated/IR/Builtin/AffineMapAttr.cpp
deleted file mode 100644
index 3ec115366..000000000
--- a/bindings/Python/Generated/IR/Builtin/AffineMapAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::AffineMapAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[871]) || tp >= &(gTypes[872])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::AffineMapAttr::static_kind():
-      tp = &(gTypes[871]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AffineMapAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::AffineMapAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::AffineMapAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[871]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.AffineMapAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::AffineMapAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AffineMapAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AffineMapAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AffineMapAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/ArrayAttr.cpp b/bindings/Python/Generated/IR/Builtin/ArrayAttr.cpp
deleted file mode 100644
index 202cfc521..000000000
--- a/bindings/Python/Generated/IR/Builtin/ArrayAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::ArrayAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[872]) || tp >= &(gTypes[873])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::ArrayAttr::static_kind():
-      tp = &(gTypes[872]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ArrayAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ArrayAttr::size"),
-    nullptr,
-  },
-  {
-    "empty",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->empty());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ArrayAttr::empty"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ArrayAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ArrayAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[872]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.ArrayAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::ArrayAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ArrayAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ArrayAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ArrayAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Attribute.cpp b/bindings/Python/Generated/IR/Builtin/Attribute.cpp
deleted file mode 100644
index 2f816897d..000000000
--- a/bindings/Python/Generated/IR/Builtin/Attribute.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Attribute;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[868]) || tp >= &(gTypes[892])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::TypedAttr::static_kind():
-      tp = &(gTypes[869]);
-      break;
-
-    case mx::ir::builtin::ElementsAttr::static_kind():
-      tp = &(gTypes[870]);
-      break;
-
-    case mx::ir::builtin::AffineMapAttr::static_kind():
-      tp = &(gTypes[871]);
-      break;
-
-    case mx::ir::builtin::ArrayAttr::static_kind():
-      tp = &(gTypes[872]);
-      break;
-
-    case mx::ir::builtin::DenseArrayAttr::static_kind():
-      tp = &(gTypes[873]);
-      break;
-
-    case mx::ir::builtin::DenseIntOrFPElementsAttr::static_kind():
-      tp = &(gTypes[874]);
-      break;
-
-    case mx::ir::builtin::DenseStringElementsAttr::static_kind():
-      tp = &(gTypes[875]);
-      break;
-
-    case mx::ir::builtin::DenseResourceElementsAttr::static_kind():
-      tp = &(gTypes[876]);
-      break;
-
-    case mx::ir::builtin::DictionaryAttr::static_kind():
-      tp = &(gTypes[877]);
-      break;
-
-    case mx::ir::builtin::FloatAttr::static_kind():
-      tp = &(gTypes[878]);
-      break;
-
-    case mx::ir::builtin::IntegerAttr::static_kind():
-      tp = &(gTypes[879]);
-      break;
-
-    case mx::ir::builtin::IntegerSetAttr::static_kind():
-      tp = &(gTypes[880]);
-      break;
-
-    case mx::ir::builtin::OpaqueAttr::static_kind():
-      tp = &(gTypes[881]);
-      break;
-
-    case mx::ir::builtin::SparseElementsAttr::static_kind():
-      tp = &(gTypes[882]);
-      break;
-
-    case mx::ir::builtin::StridedLayoutAttr::static_kind():
-      tp = &(gTypes[883]);
-      break;
-
-    case mx::ir::builtin::StringAttr::static_kind():
-      tp = &(gTypes[884]);
-      break;
-
-    case mx::ir::builtin::SymbolRefAttr::static_kind():
-      tp = &(gTypes[885]);
-      break;
-
-    case mx::ir::builtin::TypeAttr::static_kind():
-      tp = &(gTypes[886]);
-      break;
-
-    case mx::ir::builtin::UnitAttr::static_kind():
-      tp = &(gTypes[887]);
-      break;
-
-    case mx::ir::builtin::BoolAttr::static_kind():
-      tp = &(gTypes[888]);
-      break;
-
-    case mx::ir::builtin::FlatSymbolRefAttr::static_kind():
-      tp = &(gTypes[889]);
-      break;
-
-    case mx::ir::builtin::DenseIntElementsAttr::static_kind():
-      tp = &(gTypes[890]);
-      break;
-
-    case mx::ir::builtin::DataLayoutSpecAttr::static_kind():
-      tp = &(gTypes[891]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Attribute", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Attribute::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[868]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Attribute";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Attribute");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[867].tp_hash;
-  tp->tp_richcompare = gTypes[867].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[867]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Attribute.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Attribute.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Attribute' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/BFloat16Type.cpp b/bindings/Python/Generated/IR/Builtin/BFloat16Type.cpp
deleted file mode 100644
index f53261cd8..000000000
--- a/bindings/Python/Generated/IR/Builtin/BFloat16Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::BFloat16Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1471]) || tp >= &(gTypes[1472])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::BFloat16Type::static_kind():
-      tp = &(gTypes[1471]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BFloat16Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::BFloat16Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::BFloat16Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1471]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.BFloat16Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::BFloat16Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BFloat16Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BFloat16Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BFloat16Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/BoolAttr.cpp b/bindings/Python/Generated/IR/Builtin/BoolAttr.cpp
deleted file mode 100644
index e3ac2aac3..000000000
--- a/bindings/Python/Generated/IR/Builtin/BoolAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::BoolAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[888]) || tp >= &(gTypes[889])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::BoolAttr::static_kind():
-      tp = &(gTypes[888]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BoolAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::BoolAttr::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::BoolAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::BoolAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[888]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.BoolAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::BoolAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BoolAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BoolAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BoolAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/ComplexType.cpp b/bindings/Python/Generated/IR/Builtin/ComplexType.cpp
deleted file mode 100644
index 5c0edc1dd..000000000
--- a/bindings/Python/Generated/IR/Builtin/ComplexType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::ComplexType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1465]) || tp >= &(gTypes[1466])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::ComplexType::static_kind():
-      tp = &(gTypes[1465]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ComplexType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ComplexType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ComplexType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1465]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.ComplexType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::ComplexType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ComplexType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ComplexType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ComplexType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/DataLayoutSpecAttr.cpp b/bindings/Python/Generated/IR/Builtin/DataLayoutSpecAttr.cpp
deleted file mode 100644
index e402d4df9..000000000
--- a/bindings/Python/Generated/IR/Builtin/DataLayoutSpecAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::DataLayoutSpecAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[891]) || tp >= &(gTypes[892])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::DataLayoutSpecAttr::static_kind():
-      tp = &(gTypes[891]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DataLayoutSpecAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DataLayoutSpecAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DataLayoutSpecAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[891]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.DataLayoutSpecAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::DataLayoutSpecAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DataLayoutSpecAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DataLayoutSpecAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DataLayoutSpecAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/DenseArrayAttr.cpp b/bindings/Python/Generated/IR/Builtin/DenseArrayAttr.cpp
deleted file mode 100644
index 25fa8d5b7..000000000
--- a/bindings/Python/Generated/IR/Builtin/DenseArrayAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::DenseArrayAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[873]) || tp >= &(gTypes[874])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::DenseArrayAttr::static_kind():
-      tp = &(gTypes[873]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DenseArrayAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseArrayAttr::size"),
-    nullptr,
-  },
-  {
-    "empty",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->empty());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseArrayAttr::empty"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseArrayAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseArrayAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[873]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.DenseArrayAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::DenseArrayAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DenseArrayAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DenseArrayAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DenseArrayAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/DenseIntElementsAttr.cpp b/bindings/Python/Generated/IR/Builtin/DenseIntElementsAttr.cpp
deleted file mode 100644
index 06e34de11..000000000
--- a/bindings/Python/Generated/IR/Builtin/DenseIntElementsAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::DenseIntElementsAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[890]) || tp >= &(gTypes[891])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::DenseIntElementsAttr::static_kind():
-      tp = &(gTypes[890]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DenseIntElementsAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseIntElementsAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseIntElementsAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[890]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.DenseIntElementsAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::DenseIntElementsAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DenseIntElementsAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DenseIntElementsAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DenseIntElementsAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/DenseIntOrFPElementsAttr.cpp b/bindings/Python/Generated/IR/Builtin/DenseIntOrFPElementsAttr.cpp
deleted file mode 100644
index 4772dd050..000000000
--- a/bindings/Python/Generated/IR/Builtin/DenseIntOrFPElementsAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::DenseIntOrFPElementsAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[874]) || tp >= &(gTypes[875])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::DenseIntOrFPElementsAttr::static_kind():
-      tp = &(gTypes[874]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DenseIntOrFPElementsAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseIntOrFPElementsAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseIntOrFPElementsAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[874]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.DenseIntOrFPElementsAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::DenseIntOrFPElementsAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DenseIntOrFPElementsAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DenseIntOrFPElementsAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DenseIntOrFPElementsAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/DenseResourceElementsAttr.cpp b/bindings/Python/Generated/IR/Builtin/DenseResourceElementsAttr.cpp
deleted file mode 100644
index ad490acf8..000000000
--- a/bindings/Python/Generated/IR/Builtin/DenseResourceElementsAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::DenseResourceElementsAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[876]) || tp >= &(gTypes[877])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::DenseResourceElementsAttr::static_kind():
-      tp = &(gTypes[876]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DenseResourceElementsAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseResourceElementsAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseResourceElementsAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[876]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.DenseResourceElementsAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::DenseResourceElementsAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DenseResourceElementsAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DenseResourceElementsAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DenseResourceElementsAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/DenseStringElementsAttr.cpp b/bindings/Python/Generated/IR/Builtin/DenseStringElementsAttr.cpp
deleted file mode 100644
index ee128cae1..000000000
--- a/bindings/Python/Generated/IR/Builtin/DenseStringElementsAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::DenseStringElementsAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[875]) || tp >= &(gTypes[876])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::DenseStringElementsAttr::static_kind():
-      tp = &(gTypes[875]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DenseStringElementsAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseStringElementsAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DenseStringElementsAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[875]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.DenseStringElementsAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::DenseStringElementsAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DenseStringElementsAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DenseStringElementsAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DenseStringElementsAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/DictionaryAttr.cpp b/bindings/Python/Generated/IR/Builtin/DictionaryAttr.cpp
deleted file mode 100644
index 5318d0d4e..000000000
--- a/bindings/Python/Generated/IR/Builtin/DictionaryAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::DictionaryAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[877]) || tp >= &(gTypes[878])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::DictionaryAttr::static_kind():
-      tp = &(gTypes[877]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DictionaryAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "empty",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->empty());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DictionaryAttr::empty"),
-    nullptr,
-  },
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DictionaryAttr::size"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DictionaryAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::DictionaryAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[877]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.DictionaryAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::DictionaryAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DictionaryAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DictionaryAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DictionaryAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/ElementsAttr.cpp b/bindings/Python/Generated/IR/Builtin/ElementsAttr.cpp
deleted file mode 100644
index 6fb75df85..000000000
--- a/bindings/Python/Generated/IR/Builtin/ElementsAttr.cpp
+++ /dev/null
@@ -1,284 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::ElementsAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[870]) || tp >= &(gTypes[871])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::ElementsAttr::static_kind():
-      tp = &(gTypes[870]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ElementsAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_splat",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_splat());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ElementsAttr::is_splat"),
-    nullptr,
-  },
-  {
-    "num_elements",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_elements());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ElementsAttr::num_elements"),
-    nullptr,
-  },
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ElementsAttr::size"),
-    nullptr,
-  },
-  {
-    "empty",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->empty());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ElementsAttr::empty"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ElementsAttr::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ElementsAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ElementsAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[870]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.ElementsAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::ElementsAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ElementsAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ElementsAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ElementsAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/FlatSymbolRefAttr.cpp b/bindings/Python/Generated/IR/Builtin/FlatSymbolRefAttr.cpp
deleted file mode 100644
index 551878b27..000000000
--- a/bindings/Python/Generated/IR/Builtin/FlatSymbolRefAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::FlatSymbolRefAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[889]) || tp >= &(gTypes[890])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::FlatSymbolRefAttr::static_kind():
-      tp = &(gTypes[889]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FlatSymbolRefAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FlatSymbolRefAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FlatSymbolRefAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[889]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.FlatSymbolRefAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::FlatSymbolRefAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FlatSymbolRefAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FlatSymbolRefAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FlatSymbolRefAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float128Type.cpp b/bindings/Python/Generated/IR/Builtin/Float128Type.cpp
deleted file mode 100644
index 0f39e71d0..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float128Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float128Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1477]) || tp >= &(gTypes[1478])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float128Type::static_kind():
-      tp = &(gTypes[1477]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float128Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float128Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float128Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1477]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float128Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float128Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float128Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float128Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float128Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float16Type.cpp b/bindings/Python/Generated/IR/Builtin/Float16Type.cpp
deleted file mode 100644
index be5bce670..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float16Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float16Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1472]) || tp >= &(gTypes[1473])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float16Type::static_kind():
-      tp = &(gTypes[1472]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float16Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float16Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float16Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1472]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float16Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float16Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float16Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float16Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float16Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float32Type.cpp b/bindings/Python/Generated/IR/Builtin/Float32Type.cpp
deleted file mode 100644
index 171d7a1d4..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float32Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float32Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1474]) || tp >= &(gTypes[1475])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float32Type::static_kind():
-      tp = &(gTypes[1474]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float32Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float32Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float32Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1474]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float32Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float32Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float32Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float32Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float32Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float64Type.cpp b/bindings/Python/Generated/IR/Builtin/Float64Type.cpp
deleted file mode 100644
index e458b0abf..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float64Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float64Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1475]) || tp >= &(gTypes[1476])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float64Type::static_kind():
-      tp = &(gTypes[1475]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float64Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float64Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float64Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1475]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float64Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float64Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float64Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float64Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float64Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float80Type.cpp b/bindings/Python/Generated/IR/Builtin/Float80Type.cpp
deleted file mode 100644
index c6810b17f..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float80Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float80Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1476]) || tp >= &(gTypes[1477])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float80Type::static_kind():
-      tp = &(gTypes[1476]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float80Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float80Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float80Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1476]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float80Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float80Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float80Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float80Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float80Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float8E4M3B11FNUZType.cpp b/bindings/Python/Generated/IR/Builtin/Float8E4M3B11FNUZType.cpp
deleted file mode 100644
index 534ee9c8d..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float8E4M3B11FNUZType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float8E4M3B11FNUZType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1470]) || tp >= &(gTypes[1471])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float8E4M3B11FNUZType::static_kind():
-      tp = &(gTypes[1470]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float8E4M3B11FNUZType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E4M3B11FNUZType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E4M3B11FNUZType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1470]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float8E4M3B11FNUZType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float8E4M3B11FNUZType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float8E4M3B11FNUZType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float8E4M3B11FNUZType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float8E4M3B11FNUZType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float8E4M3FNType.cpp b/bindings/Python/Generated/IR/Builtin/Float8E4M3FNType.cpp
deleted file mode 100644
index be7c63d69..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float8E4M3FNType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float8E4M3FNType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1467]) || tp >= &(gTypes[1468])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float8E4M3FNType::static_kind():
-      tp = &(gTypes[1467]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float8E4M3FNType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E4M3FNType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E4M3FNType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1467]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float8E4M3FNType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float8E4M3FNType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float8E4M3FNType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float8E4M3FNType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float8E4M3FNType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float8E4M3FNUZType.cpp b/bindings/Python/Generated/IR/Builtin/Float8E4M3FNUZType.cpp
deleted file mode 100644
index e38cf495d..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float8E4M3FNUZType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float8E4M3FNUZType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1469]) || tp >= &(gTypes[1470])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float8E4M3FNUZType::static_kind():
-      tp = &(gTypes[1469]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float8E4M3FNUZType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E4M3FNUZType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E4M3FNUZType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1469]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float8E4M3FNUZType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float8E4M3FNUZType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float8E4M3FNUZType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float8E4M3FNUZType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float8E4M3FNUZType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float8E5M2FNUZType.cpp b/bindings/Python/Generated/IR/Builtin/Float8E5M2FNUZType.cpp
deleted file mode 100644
index 3477eb473..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float8E5M2FNUZType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float8E5M2FNUZType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1468]) || tp >= &(gTypes[1469])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float8E5M2FNUZType::static_kind():
-      tp = &(gTypes[1468]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float8E5M2FNUZType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E5M2FNUZType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E5M2FNUZType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1468]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float8E5M2FNUZType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float8E5M2FNUZType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float8E5M2FNUZType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float8E5M2FNUZType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float8E5M2FNUZType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Float8E5M2Type.cpp b/bindings/Python/Generated/IR/Builtin/Float8E5M2Type.cpp
deleted file mode 100644
index dd1d79662..000000000
--- a/bindings/Python/Generated/IR/Builtin/Float8E5M2Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Float8E5M2Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1466]) || tp >= &(gTypes[1467])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::Float8E5M2Type::static_kind():
-      tp = &(gTypes[1466]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float8E5M2Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E5M2Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Float8E5M2Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1466]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Float8E5M2Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Float8E5M2Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float8E5M2Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float8E5M2Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float8E5M2Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/FloatAttr.cpp b/bindings/Python/Generated/IR/Builtin/FloatAttr.cpp
deleted file mode 100644
index 672767c31..000000000
--- a/bindings/Python/Generated/IR/Builtin/FloatAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::FloatAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[878]) || tp >= &(gTypes[879])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::FloatAttr::static_kind():
-      tp = &(gTypes[878]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FloatAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value_as_double",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value_as_double());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatAttr::value_as_double"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatAttr::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[878]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.FloatAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::FloatAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FloatAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FloatAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FloatAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/FloatTF32Type.cpp b/bindings/Python/Generated/IR/Builtin/FloatTF32Type.cpp
deleted file mode 100644
index a33cf674c..000000000
--- a/bindings/Python/Generated/IR/Builtin/FloatTF32Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::FloatTF32Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1473]) || tp >= &(gTypes[1474])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::FloatTF32Type::static_kind():
-      tp = &(gTypes[1473]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FloatTF32Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatTF32Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatTF32Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1473]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.FloatTF32Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::FloatTF32Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FloatTF32Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FloatTF32Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FloatTF32Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/FloatType.cpp b/bindings/Python/Generated/IR/Builtin/FloatType.cpp
deleted file mode 100644
index 80c13f489..000000000
--- a/bindings/Python/Generated/IR/Builtin/FloatType.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::FloatType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1464]) || tp >= &(gTypes[1465])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::FloatType::static_kind():
-      tp = &(gTypes[1464]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FloatType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "width",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->width());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatType::width"),
-    nullptr,
-  },
-  {
-    "fp_mantissa_width",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->fp_mantissa_width());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatType::fp_mantissa_width"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FloatType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1464]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.FloatType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::FloatType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FloatType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FloatType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FloatType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/FunctionType.cpp b/bindings/Python/Generated/IR/Builtin/FunctionType.cpp
deleted file mode 100644
index c12ecde60..000000000
--- a/bindings/Python/Generated/IR/Builtin/FunctionType.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::FunctionType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1478]) || tp >= &(gTypes[1479])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::FunctionType::static_kind():
-      tp = &(gTypes[1478]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FunctionType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "num_inputs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_inputs());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FunctionType::num_inputs"),
-    nullptr,
-  },
-  {
-    "num_results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_results());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FunctionType::num_results"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FunctionType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::FunctionType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1478]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.FunctionType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::FunctionType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FunctionType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FunctionType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FunctionType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/IndexType.cpp b/bindings/Python/Generated/IR/Builtin/IndexType.cpp
deleted file mode 100644
index cc296585f..000000000
--- a/bindings/Python/Generated/IR/Builtin/IndexType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::IndexType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1479]) || tp >= &(gTypes[1480])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::IndexType::static_kind():
-      tp = &(gTypes[1479]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IndexType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IndexType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IndexType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1479]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.IndexType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::IndexType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IndexType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IndexType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IndexType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/IntegerAttr.cpp b/bindings/Python/Generated/IR/Builtin/IntegerAttr.cpp
deleted file mode 100644
index 1884d7ed9..000000000
--- a/bindings/Python/Generated/IR/Builtin/IntegerAttr.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::IntegerAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[879]) || tp >= &(gTypes[880])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::IntegerAttr::static_kind():
-      tp = &(gTypes[879]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IntegerAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "integer_value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->integer_value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerAttr::integer_value"),
-    nullptr,
-  },
-  {
-    "signed_integer_value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->signed_integer_value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerAttr::signed_integer_value"),
-    nullptr,
-  },
-  {
-    "unsigned_integer_value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->unsigned_integer_value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerAttr::unsigned_integer_value"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerAttr::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[879]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.IntegerAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::IntegerAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IntegerAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IntegerAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IntegerAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/IntegerSetAttr.cpp b/bindings/Python/Generated/IR/Builtin/IntegerSetAttr.cpp
deleted file mode 100644
index 210ac6136..000000000
--- a/bindings/Python/Generated/IR/Builtin/IntegerSetAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::IntegerSetAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[880]) || tp >= &(gTypes[881])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::IntegerSetAttr::static_kind():
-      tp = &(gTypes[880]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IntegerSetAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerSetAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerSetAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[880]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.IntegerSetAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::IntegerSetAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IntegerSetAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IntegerSetAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IntegerSetAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/IntegerType.cpp b/bindings/Python/Generated/IR/Builtin/IntegerType.cpp
deleted file mode 100644
index a6a827e7e..000000000
--- a/bindings/Python/Generated/IR/Builtin/IntegerType.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::IntegerType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1480]) || tp >= &(gTypes[1481])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::IntegerType::static_kind():
-      tp = &(gTypes[1480]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IntegerType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_signless",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_signless());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerType::is_signless"),
-    nullptr,
-  },
-  {
-    "is_signed",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_signed());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerType::is_signed"),
-    nullptr,
-  },
-  {
-    "is_unsigned",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_unsigned());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerType::is_unsigned"),
-    nullptr,
-  },
-  {
-    "width",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->width());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerType::width"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::IntegerType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1480]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.IntegerType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::IntegerType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IntegerType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IntegerType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IntegerType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/MemRefType.cpp b/bindings/Python/Generated/IR/Builtin/MemRefType.cpp
deleted file mode 100644
index a9f8d263a..000000000
--- a/bindings/Python/Generated/IR/Builtin/MemRefType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::MemRefType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1481]) || tp >= &(gTypes[1482])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::MemRefType::static_kind():
-      tp = &(gTypes[1481]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MemRefType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "memory_space_as_int",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->memory_space_as_int());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::MemRefType::memory_space_as_int"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::MemRefType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::MemRefType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1481]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.MemRefType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::MemRefType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MemRefType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MemRefType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MemRefType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/ModuleOp.cpp b/bindings/Python/Generated/IR/Builtin/ModuleOp.cpp
deleted file mode 100644
index a91848d79..000000000
--- a/bindings/Python/Generated/IR/Builtin/ModuleOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::ModuleOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1000]) || tp >= &(gTypes[1001])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::ModuleOp::static_kind():
-      tp = &(gTypes[1000]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ModuleOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ModuleOp::body_region"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ModuleOp::name"),
-    nullptr,
-  },
-  {
-    "visibility",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->visibility());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ModuleOp::visibility"),
-    nullptr,
-  },
-  {
-    "is_optional_symbol",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_optional_symbol());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ModuleOp::is_optional_symbol"),
-    nullptr,
-  },
-  {
-    "default_dialect",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->default_dialect());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ModuleOp::default_dialect"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ModuleOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ModuleOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ModuleOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1000]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.ModuleOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::ModuleOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[999].tp_hash;
-  tp->tp_richcompare = gTypes[999].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[999]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ModuleOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ModuleOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ModuleOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/NoneType.cpp b/bindings/Python/Generated/IR/Builtin/NoneType.cpp
deleted file mode 100644
index 187560a0d..000000000
--- a/bindings/Python/Generated/IR/Builtin/NoneType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::NoneType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1482]) || tp >= &(gTypes[1483])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::NoneType::static_kind():
-      tp = &(gTypes[1482]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NoneType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::NoneType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::NoneType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1482]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.NoneType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::NoneType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NoneType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NoneType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NoneType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/OpaqueAttr.cpp b/bindings/Python/Generated/IR/Builtin/OpaqueAttr.cpp
deleted file mode 100644
index 79c1065ea..000000000
--- a/bindings/Python/Generated/IR/Builtin/OpaqueAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::OpaqueAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[881]) || tp >= &(gTypes[882])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::OpaqueAttr::static_kind():
-      tp = &(gTypes[881]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "OpaqueAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "attr_data",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->attr_data());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::OpaqueAttr::attr_data"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::OpaqueAttr::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::OpaqueAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::OpaqueAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[881]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.OpaqueAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::OpaqueAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'OpaqueAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'OpaqueAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'OpaqueAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/OpaqueType.cpp b/bindings/Python/Generated/IR/Builtin/OpaqueType.cpp
deleted file mode 100644
index 3ee005d8a..000000000
--- a/bindings/Python/Generated/IR/Builtin/OpaqueType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::OpaqueType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1483]) || tp >= &(gTypes[1484])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::OpaqueType::static_kind():
-      tp = &(gTypes[1483]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "OpaqueType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "type_data",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type_data());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::OpaqueType::type_data"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::OpaqueType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::OpaqueType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1483]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.OpaqueType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::OpaqueType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'OpaqueType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'OpaqueType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'OpaqueType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Operation.cpp b/bindings/Python/Generated/IR/Builtin/Operation.cpp
deleted file mode 100644
index 2ee2bc931..000000000
--- a/bindings/Python/Generated/IR/Builtin/Operation.cpp
+++ /dev/null
@@ -1,221 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Operation;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[999]) || tp >= &(gTypes[1002])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::ModuleOp::static_kind():
-      tp = &(gTypes[1000]);
-      break;
-
-    case mx::ir::builtin::UnrealizedConversionCastOp::static_kind():
-      tp = &(gTypes[1001]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operation", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Operation::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[999]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Operation";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Operation");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[998].tp_hash;
-  tp->tp_richcompare = gTypes[998].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[998]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operation.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operation.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operation' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/RankedTensorType.cpp b/bindings/Python/Generated/IR/Builtin/RankedTensorType.cpp
deleted file mode 100644
index cfe9e5f4c..000000000
--- a/bindings/Python/Generated/IR/Builtin/RankedTensorType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::RankedTensorType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1484]) || tp >= &(gTypes[1485])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::RankedTensorType::static_kind():
-      tp = &(gTypes[1484]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RankedTensorType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::RankedTensorType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::RankedTensorType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1484]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.RankedTensorType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::RankedTensorType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RankedTensorType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RankedTensorType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RankedTensorType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/ShapedType.cpp b/bindings/Python/Generated/IR/Builtin/ShapedType.cpp
deleted file mode 100644
index 9a719890e..000000000
--- a/bindings/Python/Generated/IR/Builtin/ShapedType.cpp
+++ /dev/null
@@ -1,304 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::ShapedType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1463]) || tp >= &(gTypes[1464])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::ShapedType::static_kind():
-      tp = &(gTypes[1463]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ShapedType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "element_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->element_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ShapedType::element_type"),
-    nullptr,
-  },
-  {
-    "has_rank",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->has_rank());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ShapedType::has_rank"),
-    nullptr,
-  },
-  {
-    "element_type_bit_width",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->element_type_bit_width());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ShapedType::element_type_bit_width"),
-    nullptr,
-  },
-  {
-    "rank",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->rank());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ShapedType::rank"),
-    nullptr,
-  },
-  {
-    "num_elements",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_elements());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ShapedType::num_elements"),
-    nullptr,
-  },
-  {
-    "has_static_shape",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->has_static_shape());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ShapedType::has_static_shape"),
-    nullptr,
-  },
-  {
-    "num_dynamic_dims",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_dynamic_dims());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ShapedType::num_dynamic_dims"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ShapedType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::ShapedType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1463]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.ShapedType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::ShapedType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ShapedType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ShapedType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ShapedType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/SparseElementsAttr.cpp b/bindings/Python/Generated/IR/Builtin/SparseElementsAttr.cpp
deleted file mode 100644
index 865162dcb..000000000
--- a/bindings/Python/Generated/IR/Builtin/SparseElementsAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::SparseElementsAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[882]) || tp >= &(gTypes[883])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::SparseElementsAttr::static_kind():
-      tp = &(gTypes[882]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SparseElementsAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::SparseElementsAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::SparseElementsAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[882]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.SparseElementsAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::SparseElementsAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SparseElementsAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SparseElementsAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SparseElementsAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/StridedLayoutAttr.cpp b/bindings/Python/Generated/IR/Builtin/StridedLayoutAttr.cpp
deleted file mode 100644
index 793f8dbd8..000000000
--- a/bindings/Python/Generated/IR/Builtin/StridedLayoutAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::StridedLayoutAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[883]) || tp >= &(gTypes[884])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::StridedLayoutAttr::static_kind():
-      tp = &(gTypes[883]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StridedLayoutAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "offset",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->offset());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StridedLayoutAttr::offset"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StridedLayoutAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StridedLayoutAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[883]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.StridedLayoutAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::StridedLayoutAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StridedLayoutAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StridedLayoutAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StridedLayoutAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/StringAttr.cpp b/bindings/Python/Generated/IR/Builtin/StringAttr.cpp
deleted file mode 100644
index cfa317e95..000000000
--- a/bindings/Python/Generated/IR/Builtin/StringAttr.cpp
+++ /dev/null
@@ -1,284 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::StringAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[884]) || tp >= &(gTypes[885])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::StringAttr::static_kind():
-      tp = &(gTypes[884]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StringAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "str",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->str());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StringAttr::str"),
-    nullptr,
-  },
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StringAttr::size"),
-    nullptr,
-  },
-  {
-    "empty",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->empty());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StringAttr::empty"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StringAttr::value"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StringAttr::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StringAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::StringAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[884]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.StringAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::StringAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StringAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StringAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StringAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/SymbolRefAttr.cpp b/bindings/Python/Generated/IR/Builtin/SymbolRefAttr.cpp
deleted file mode 100644
index 57ddf444a..000000000
--- a/bindings/Python/Generated/IR/Builtin/SymbolRefAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::SymbolRefAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[885]) || tp >= &(gTypes[886])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::SymbolRefAttr::static_kind():
-      tp = &(gTypes[885]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SymbolRefAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::SymbolRefAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::SymbolRefAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[885]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.SymbolRefAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::SymbolRefAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SymbolRefAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SymbolRefAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SymbolRefAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/TupleType.cpp b/bindings/Python/Generated/IR/Builtin/TupleType.cpp
deleted file mode 100644
index 9bd409c5f..000000000
--- a/bindings/Python/Generated/IR/Builtin/TupleType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::TupleType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1485]) || tp >= &(gTypes[1486])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::TupleType::static_kind():
-      tp = &(gTypes[1485]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TupleType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::TupleType::size"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::TupleType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::TupleType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1485]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.TupleType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::TupleType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TupleType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TupleType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TupleType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/Type.cpp b/bindings/Python/Generated/IR/Builtin/Type.cpp
deleted file mode 100644
index 83581938c..000000000
--- a/bindings/Python/Generated/IR/Builtin/Type.cpp
+++ /dev/null
@@ -1,317 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1462]) || tp >= &(gTypes[1489])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::ShapedType::static_kind():
-      tp = &(gTypes[1463]);
-      break;
-
-    case mx::ir::builtin::FloatType::static_kind():
-      tp = &(gTypes[1464]);
-      break;
-
-    case mx::ir::builtin::ComplexType::static_kind():
-      tp = &(gTypes[1465]);
-      break;
-
-    case mx::ir::builtin::Float8E5M2Type::static_kind():
-      tp = &(gTypes[1466]);
-      break;
-
-    case mx::ir::builtin::Float8E4M3FNType::static_kind():
-      tp = &(gTypes[1467]);
-      break;
-
-    case mx::ir::builtin::Float8E5M2FNUZType::static_kind():
-      tp = &(gTypes[1468]);
-      break;
-
-    case mx::ir::builtin::Float8E4M3FNUZType::static_kind():
-      tp = &(gTypes[1469]);
-      break;
-
-    case mx::ir::builtin::Float8E4M3B11FNUZType::static_kind():
-      tp = &(gTypes[1470]);
-      break;
-
-    case mx::ir::builtin::BFloat16Type::static_kind():
-      tp = &(gTypes[1471]);
-      break;
-
-    case mx::ir::builtin::Float16Type::static_kind():
-      tp = &(gTypes[1472]);
-      break;
-
-    case mx::ir::builtin::FloatTF32Type::static_kind():
-      tp = &(gTypes[1473]);
-      break;
-
-    case mx::ir::builtin::Float32Type::static_kind():
-      tp = &(gTypes[1474]);
-      break;
-
-    case mx::ir::builtin::Float64Type::static_kind():
-      tp = &(gTypes[1475]);
-      break;
-
-    case mx::ir::builtin::Float80Type::static_kind():
-      tp = &(gTypes[1476]);
-      break;
-
-    case mx::ir::builtin::Float128Type::static_kind():
-      tp = &(gTypes[1477]);
-      break;
-
-    case mx::ir::builtin::FunctionType::static_kind():
-      tp = &(gTypes[1478]);
-      break;
-
-    case mx::ir::builtin::IndexType::static_kind():
-      tp = &(gTypes[1479]);
-      break;
-
-    case mx::ir::builtin::IntegerType::static_kind():
-      tp = &(gTypes[1480]);
-      break;
-
-    case mx::ir::builtin::MemRefType::static_kind():
-      tp = &(gTypes[1481]);
-      break;
-
-    case mx::ir::builtin::NoneType::static_kind():
-      tp = &(gTypes[1482]);
-      break;
-
-    case mx::ir::builtin::OpaqueType::static_kind():
-      tp = &(gTypes[1483]);
-      break;
-
-    case mx::ir::builtin::RankedTensorType::static_kind():
-      tp = &(gTypes[1484]);
-      break;
-
-    case mx::ir::builtin::TupleType::static_kind():
-      tp = &(gTypes[1485]);
-      break;
-
-    case mx::ir::builtin::UnrankedMemRefType::static_kind():
-      tp = &(gTypes[1486]);
-      break;
-
-    case mx::ir::builtin::UnrankedTensorType::static_kind():
-      tp = &(gTypes[1487]);
-      break;
-
-    case mx::ir::builtin::VectorType::static_kind():
-      tp = &(gTypes[1488]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1462]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1461].tp_hash;
-  tp->tp_richcompare = gTypes[1461].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1461]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/TypeAttr.cpp b/bindings/Python/Generated/IR/Builtin/TypeAttr.cpp
deleted file mode 100644
index 2b05d97ac..000000000
--- a/bindings/Python/Generated/IR/Builtin/TypeAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::TypeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[886]) || tp >= &(gTypes[887])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::TypeAttr::static_kind():
-      tp = &(gTypes[886]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::TypeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::TypeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[886]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.TypeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::TypeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/TypedAttr.cpp b/bindings/Python/Generated/IR/Builtin/TypedAttr.cpp
deleted file mode 100644
index a538b243a..000000000
--- a/bindings/Python/Generated/IR/Builtin/TypedAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::TypedAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[869]) || tp >= &(gTypes[870])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::TypedAttr::static_kind():
-      tp = &(gTypes[869]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypedAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::TypedAttr::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::TypedAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::TypedAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[869]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.TypedAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::TypedAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypedAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypedAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypedAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/UnitAttr.cpp b/bindings/Python/Generated/IR/Builtin/UnitAttr.cpp
deleted file mode 100644
index e42b42782..000000000
--- a/bindings/Python/Generated/IR/Builtin/UnitAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::UnitAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[887]) || tp >= &(gTypes[888])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::UnitAttr::static_kind():
-      tp = &(gTypes[887]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnitAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnitAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnitAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[887]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.UnitAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::UnitAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[868].tp_hash;
-  tp->tp_richcompare = gTypes[868].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[868]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnitAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnitAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnitAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/UnrankedMemRefType.cpp b/bindings/Python/Generated/IR/Builtin/UnrankedMemRefType.cpp
deleted file mode 100644
index 2e878cbc0..000000000
--- a/bindings/Python/Generated/IR/Builtin/UnrankedMemRefType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::UnrankedMemRefType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1486]) || tp >= &(gTypes[1487])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::UnrankedMemRefType::static_kind():
-      tp = &(gTypes[1486]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnrankedMemRefType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "memory_space_as_int",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->memory_space_as_int());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrankedMemRefType::memory_space_as_int"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrankedMemRefType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrankedMemRefType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1486]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.UnrankedMemRefType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::UnrankedMemRefType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnrankedMemRefType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnrankedMemRefType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnrankedMemRefType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/UnrankedTensorType.cpp b/bindings/Python/Generated/IR/Builtin/UnrankedTensorType.cpp
deleted file mode 100644
index 79ee4e0b6..000000000
--- a/bindings/Python/Generated/IR/Builtin/UnrankedTensorType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::UnrankedTensorType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1487]) || tp >= &(gTypes[1488])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::UnrankedTensorType::static_kind():
-      tp = &(gTypes[1487]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnrankedTensorType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrankedTensorType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrankedTensorType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1487]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.UnrankedTensorType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::UnrankedTensorType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnrankedTensorType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnrankedTensorType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnrankedTensorType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/UnrealizedConversionCastOp.cpp b/bindings/Python/Generated/IR/Builtin/UnrealizedConversionCastOp.cpp
deleted file mode 100644
index b5ece3019..000000000
--- a/bindings/Python/Generated/IR/Builtin/UnrealizedConversionCastOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::UnrealizedConversionCastOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1001]) || tp >= &(gTypes[1002])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::UnrealizedConversionCastOp::static_kind():
-      tp = &(gTypes[1001]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnrealizedConversionCastOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "inputs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::inputs);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrealizedConversionCastOp::inputs"),
-    nullptr,
-  },
-  {
-    "outputs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::outputs);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrealizedConversionCastOp::outputs"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrealizedConversionCastOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrealizedConversionCastOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::UnrealizedConversionCastOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1001]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.UnrealizedConversionCastOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::UnrealizedConversionCastOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[999].tp_hash;
-  tp->tp_richcompare = gTypes[999].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[999]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnrealizedConversionCastOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnrealizedConversionCastOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnrealizedConversionCastOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Builtin/VectorType.cpp b/bindings/Python/Generated/IR/Builtin/VectorType.cpp
deleted file mode 100644
index 44823fac0..000000000
--- a/bindings/Python/Generated/IR/Builtin/VectorType.cpp
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::builtin::VectorType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1488]) || tp >= &(gTypes[1489])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::VectorType::static_kind():
-      tp = &(gTypes[1488]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_scalable",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_scalable());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::VectorType::is_scalable"),
-    nullptr,
-  },
-  {
-    "all_dims_scalable",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->all_dims_scalable());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::VectorType::all_dims_scalable"),
-    nullptr,
-  },
-  {
-    "has_rank",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->has_rank());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::builtin::VectorType::has_rank"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::VectorType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::builtin::VectorType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1488]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.builtin.VectorType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::builtin::::VectorType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1462].tp_hash;
-  tp->tp_richcompare = gTypes[1462].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1462]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/Attribute.cpp b/bindings/Python/Generated/IR/Core/Attribute.cpp
deleted file mode 100644
index 6fd026af3..000000000
--- a/bindings/Python/Generated/IR/Core/Attribute.cpp
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::Attribute;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[984]) || tp >= &(gTypes[991])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::BooleanAttr::static_kind():
-      tp = &(gTypes[985]);
-      break;
-
-    case mx::ir::core::IntegerAttr::static_kind():
-      tp = &(gTypes[986]);
-      break;
-
-    case mx::ir::core::FloatAttr::static_kind():
-      tp = &(gTypes[987]);
-      break;
-
-    case mx::ir::core::VoidAttr::static_kind():
-      tp = &(gTypes[988]);
-      break;
-
-    case mx::ir::core::SourceLanguageAttr::static_kind():
-      tp = &(gTypes[989]);
-      break;
-
-    case mx::ir::core::GlobalLinkageKindAttr::static_kind():
-      tp = &(gTypes[990]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Attribute", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::Attribute::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[984]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.Attribute";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::Attribute");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[867].tp_hash;
-  tp->tp_richcompare = gTypes[867].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[867]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Attribute.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Attribute.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Attribute' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/BinLAndOp.cpp b/bindings/Python/Generated/IR/Core/BinLAndOp.cpp
deleted file mode 100644
index 96ae0742d..000000000
--- a/bindings/Python/Generated/IR/Core/BinLAndOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::BinLAndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1448]) || tp >= &(gTypes[1449])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::BinLAndOp::static_kind():
-      tp = &(gTypes[1448]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinLAndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLAndOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLAndOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLAndOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLAndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLAndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLAndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1448]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.BinLAndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::BinLAndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1447].tp_hash;
-  tp->tp_richcompare = gTypes[1447].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1447]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinLAndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinLAndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinLAndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/BinLOrOp.cpp b/bindings/Python/Generated/IR/Core/BinLOrOp.cpp
deleted file mode 100644
index c3f71b631..000000000
--- a/bindings/Python/Generated/IR/Core/BinLOrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::BinLOrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1449]) || tp >= &(gTypes[1450])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::BinLOrOp::static_kind():
-      tp = &(gTypes[1449]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinLOrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLOrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLOrOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLOrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLOrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLOrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::BinLOrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1449]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.BinLOrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::BinLOrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1447].tp_hash;
-  tp->tp_richcompare = gTypes[1447].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1447]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinLOrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinLOrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinLOrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/BooleanAttr.cpp b/bindings/Python/Generated/IR/Core/BooleanAttr.cpp
deleted file mode 100644
index a71d8aa4b..000000000
--- a/bindings/Python/Generated/IR/Core/BooleanAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::BooleanAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[985]) || tp >= &(gTypes[986])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::BooleanAttr::static_kind():
-      tp = &(gTypes[985]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BooleanAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::BooleanAttr::type"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::BooleanAttr::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::BooleanAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::BooleanAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[985]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.BooleanAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::BooleanAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[984].tp_hash;
-  tp->tp_richcompare = gTypes[984].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[984]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BooleanAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BooleanAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BooleanAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/FloatAttr.cpp b/bindings/Python/Generated/IR/Core/FloatAttr.cpp
deleted file mode 100644
index 213d26332..000000000
--- a/bindings/Python/Generated/IR/Core/FloatAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::FloatAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[987]) || tp >= &(gTypes[988])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::FloatAttr::static_kind():
-      tp = &(gTypes[987]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FloatAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::FloatAttr::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::FloatAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::FloatAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[987]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.FloatAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::FloatAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[984].tp_hash;
-  tp->tp_richcompare = gTypes[984].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[984]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FloatAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FloatAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FloatAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/FunctionType.cpp b/bindings/Python/Generated/IR/Core/FunctionType.cpp
deleted file mode 100644
index 1ec611db7..000000000
--- a/bindings/Python/Generated/IR/Core/FunctionType.cpp
+++ /dev/null
@@ -1,294 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::FunctionType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1532]) || tp >= &(gTypes[1533])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::FunctionType::static_kind():
-      tp = &(gTypes[1532]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FunctionType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_var_arg",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_var_arg());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::FunctionType::is_var_arg"),
-    nullptr,
-  },
-  {
-    "num_inputs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_inputs());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::FunctionType::num_inputs"),
-    nullptr,
-  },
-  {
-    "num_results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_results());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::FunctionType::num_results"),
-    nullptr,
-  },
-  {
-    "inputs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::inputs);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::FunctionType::inputs"),
-    nullptr,
-  },
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::FunctionType::results"),
-    nullptr,
-  },
-  {
-    "var_arg",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->var_arg());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::FunctionType::var_arg"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::FunctionType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::FunctionType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1532]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.FunctionType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::FunctionType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1531].tp_hash;
-  tp->tp_richcompare = gTypes[1531].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1531]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FunctionType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FunctionType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FunctionType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/GlobalLinkageKindAttr.cpp b/bindings/Python/Generated/IR/Core/GlobalLinkageKindAttr.cpp
deleted file mode 100644
index bb147d4a1..000000000
--- a/bindings/Python/Generated/IR/Core/GlobalLinkageKindAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::GlobalLinkageKindAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[990]) || tp >= &(gTypes[991])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::GlobalLinkageKindAttr::static_kind():
-      tp = &(gTypes[990]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GlobalLinkageKindAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::GlobalLinkageKindAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::GlobalLinkageKindAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[990]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.GlobalLinkageKindAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::GlobalLinkageKindAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[984].tp_hash;
-  tp->tp_richcompare = gTypes[984].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[984]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GlobalLinkageKindAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GlobalLinkageKindAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GlobalLinkageKindAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/ImplicitReturnOp.cpp b/bindings/Python/Generated/IR/Core/ImplicitReturnOp.cpp
deleted file mode 100644
index b169e5efe..000000000
--- a/bindings/Python/Generated/IR/Core/ImplicitReturnOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::ImplicitReturnOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1450]) || tp >= &(gTypes[1451])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::ImplicitReturnOp::static_kind():
-      tp = &(gTypes[1450]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ImplicitReturnOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::result);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::ImplicitReturnOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::ImplicitReturnOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::ImplicitReturnOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::ImplicitReturnOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1450]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.ImplicitReturnOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::ImplicitReturnOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1447].tp_hash;
-  tp->tp_richcompare = gTypes[1447].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1447]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ImplicitReturnOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ImplicitReturnOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ImplicitReturnOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/IntegerAttr.cpp b/bindings/Python/Generated/IR/Core/IntegerAttr.cpp
deleted file mode 100644
index 540a79ab9..000000000
--- a/bindings/Python/Generated/IR/Core/IntegerAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::IntegerAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[986]) || tp >= &(gTypes[987])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::IntegerAttr::static_kind():
-      tp = &(gTypes[986]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IntegerAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::IntegerAttr::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::IntegerAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::IntegerAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[986]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.IntegerAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::IntegerAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[984].tp_hash;
-  tp->tp_richcompare = gTypes[984].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[984]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IntegerAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IntegerAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IntegerAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/LazyOp.cpp b/bindings/Python/Generated/IR/Core/LazyOp.cpp
deleted file mode 100644
index 7eaf3edc1..000000000
--- a/bindings/Python/Generated/IR/Core/LazyOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::LazyOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1451]) || tp >= &(gTypes[1452])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::LazyOp::static_kind():
-      tp = &(gTypes[1451]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LazyOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::LazyOp::result"),
-    nullptr,
-  },
-  {
-    "lazy",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->lazy());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::LazyOp::lazy"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::LazyOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::LazyOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::LazyOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1451]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.LazyOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::LazyOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1447].tp_hash;
-  tp->tp_richcompare = gTypes[1447].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1447]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LazyOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LazyOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LazyOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/ModuleOp.cpp b/bindings/Python/Generated/IR/Core/ModuleOp.cpp
deleted file mode 100644
index 2c3c3b143..000000000
--- a/bindings/Python/Generated/IR/Core/ModuleOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::ModuleOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1452]) || tp >= &(gTypes[1453])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::ModuleOp::static_kind():
-      tp = &(gTypes[1452]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ModuleOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::ModuleOp::body"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::ModuleOp::name"),
-    nullptr,
-  },
-  {
-    "is_optional_symbol",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_optional_symbol());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::ModuleOp::is_optional_symbol"),
-    nullptr,
-  },
-  {
-    "default_dialect",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->default_dialect());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::ModuleOp::default_dialect"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::ModuleOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::ModuleOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::ModuleOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1452]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.ModuleOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::ModuleOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1447].tp_hash;
-  tp->tp_richcompare = gTypes[1447].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1447]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ModuleOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ModuleOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ModuleOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/Operation.cpp b/bindings/Python/Generated/IR/Core/Operation.cpp
deleted file mode 100644
index cda51e67f..000000000
--- a/bindings/Python/Generated/IR/Core/Operation.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::Operation;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1447]) || tp >= &(gTypes[1455])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::BinLAndOp::static_kind():
-      tp = &(gTypes[1448]);
-      break;
-
-    case mx::ir::core::BinLOrOp::static_kind():
-      tp = &(gTypes[1449]);
-      break;
-
-    case mx::ir::core::ImplicitReturnOp::static_kind():
-      tp = &(gTypes[1450]);
-      break;
-
-    case mx::ir::core::LazyOp::static_kind():
-      tp = &(gTypes[1451]);
-      break;
-
-    case mx::ir::core::ModuleOp::static_kind():
-      tp = &(gTypes[1452]);
-      break;
-
-    case mx::ir::core::ScopeOp::static_kind():
-      tp = &(gTypes[1453]);
-      break;
-
-    case mx::ir::core::SelectOp::static_kind():
-      tp = &(gTypes[1454]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operation", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::Operation::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1447]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.Operation";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::Operation");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[998].tp_hash;
-  tp->tp_richcompare = gTypes[998].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[998]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operation.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operation.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operation' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/ScopeOp.cpp b/bindings/Python/Generated/IR/Core/ScopeOp.cpp
deleted file mode 100644
index 9db181271..000000000
--- a/bindings/Python/Generated/IR/Core/ScopeOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::ScopeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1453]) || tp >= &(gTypes[1454])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::ScopeOp::static_kind():
-      tp = &(gTypes[1453]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ScopeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::ScopeOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::ScopeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::ScopeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::ScopeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1453]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.ScopeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::ScopeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1447].tp_hash;
-  tp->tp_richcompare = gTypes[1447].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1447]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ScopeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ScopeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ScopeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/SelectOp.cpp b/bindings/Python/Generated/IR/Core/SelectOp.cpp
deleted file mode 100644
index ffea0b2ec..000000000
--- a/bindings/Python/Generated/IR/Core/SelectOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::SelectOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1454]) || tp >= &(gTypes[1455])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::SelectOp::static_kind():
-      tp = &(gTypes[1454]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SelectOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "cond",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->cond());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::SelectOp::cond"),
-    nullptr,
-  },
-  {
-    "then_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->then_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::SelectOp::then_region"),
-    nullptr,
-  },
-  {
-    "else_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->else_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::SelectOp::else_region"),
-    nullptr,
-  },
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::SelectOp::results"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::SelectOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::SelectOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::SelectOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1454]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.SelectOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::SelectOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1447].tp_hash;
-  tp->tp_richcompare = gTypes[1447].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1447]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SelectOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SelectOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SelectOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/SourceLanguageAttr.cpp b/bindings/Python/Generated/IR/Core/SourceLanguageAttr.cpp
deleted file mode 100644
index 907ce98d5..000000000
--- a/bindings/Python/Generated/IR/Core/SourceLanguageAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::SourceLanguageAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[989]) || tp >= &(gTypes[990])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::SourceLanguageAttr::static_kind():
-      tp = &(gTypes[989]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SourceLanguageAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::SourceLanguageAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::SourceLanguageAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[989]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.SourceLanguageAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::SourceLanguageAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[984].tp_hash;
-  tp->tp_richcompare = gTypes[984].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[984]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SourceLanguageAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SourceLanguageAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SourceLanguageAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/Type.cpp b/bindings/Python/Generated/IR/Core/Type.cpp
deleted file mode 100644
index dff048844..000000000
--- a/bindings/Python/Generated/IR/Core/Type.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1531]) || tp >= &(gTypes[1533])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::FunctionType::static_kind():
-      tp = &(gTypes[1532]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1531]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1461].tp_hash;
-  tp->tp_richcompare = gTypes[1461].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1461]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Core/VoidAttr.cpp b/bindings/Python/Generated/IR/Core/VoidAttr.cpp
deleted file mode 100644
index b76b2ddf2..000000000
--- a/bindings/Python/Generated/IR/Core/VoidAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::core::VoidAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[988]) || tp >= &(gTypes[989])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::core::VoidAttr::static_kind():
-      tp = &(gTypes[988]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VoidAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::core::VoidAttr::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::VoidAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::core::VoidAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[988]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.core.VoidAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::core::::VoidAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[984].tp_hash;
-  tp->tp_richcompare = gTypes[984].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[984]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VoidAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VoidAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VoidAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AccessSpecifierOp.cpp b/bindings/Python/Generated/IR/HighLevel/AccessSpecifierOp.cpp
deleted file mode 100644
index 89e0916c2..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AccessSpecifierOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AccessSpecifierOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1321]) || tp >= &(gTypes[1322])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AccessSpecifierOp::static_kind():
-      tp = &(gTypes[1321]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AccessSpecifierOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AccessSpecifierOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AccessSpecifierOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AccessSpecifierOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1321]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AccessSpecifierOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AccessSpecifierOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AccessSpecifierOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AccessSpecifierOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AccessSpecifierOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AddFAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/AddFAssignOp.cpp
deleted file mode 100644
index 7fb8a6944..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AddFAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AddFAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1322]) || tp >= &(gTypes[1323])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AddFAssignOp::static_kind():
-      tp = &(gTypes[1322]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AddFAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1322]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AddFAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AddFAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AddFAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AddFAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AddFAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AddFOp.cpp b/bindings/Python/Generated/IR/HighLevel/AddFOp.cpp
deleted file mode 100644
index ba079e452..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AddFOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AddFOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1323]) || tp >= &(gTypes[1324])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AddFOp::static_kind():
-      tp = &(gTypes[1323]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AddFOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddFOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1323]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AddFOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AddFOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AddFOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AddFOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AddFOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AddIAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/AddIAssignOp.cpp
deleted file mode 100644
index 69f8ec01f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AddIAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AddIAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1324]) || tp >= &(gTypes[1325])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AddIAssignOp::static_kind():
-      tp = &(gTypes[1324]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AddIAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1324]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AddIAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AddIAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AddIAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AddIAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AddIAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AddIOp.cpp b/bindings/Python/Generated/IR/HighLevel/AddIOp.cpp
deleted file mode 100644
index 7d74220b7..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AddIOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AddIOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1325]) || tp >= &(gTypes[1326])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AddIOp::static_kind():
-      tp = &(gTypes[1325]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AddIOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddIOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1325]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AddIOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AddIOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AddIOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AddIOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AddIOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AddrLabelExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/AddrLabelExprOp.cpp
deleted file mode 100644
index 0951b91bf..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AddrLabelExprOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AddrLabelExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1326]) || tp >= &(gTypes[1327])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AddrLabelExprOp::static_kind():
-      tp = &(gTypes[1326]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AddrLabelExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "label",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->label());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddrLabelExprOp::label"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddrLabelExprOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddrLabelExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddrLabelExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddrLabelExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1326]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AddrLabelExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AddrLabelExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AddrLabelExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AddrLabelExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AddrLabelExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AddressOfOp.cpp b/bindings/Python/Generated/IR/HighLevel/AddressOfOp.cpp
deleted file mode 100644
index 55fd56c75..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AddressOfOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AddressOfOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1327]) || tp >= &(gTypes[1328])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AddressOfOp::static_kind():
-      tp = &(gTypes[1327]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AddressOfOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddressOfOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddressOfOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddressOfOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddressOfOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AddressOfOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1327]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AddressOfOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AddressOfOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AddressOfOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AddressOfOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AddressOfOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AdjustedType.cpp b/bindings/Python/Generated/IR/HighLevel/AdjustedType.cpp
deleted file mode 100644
index 77531b76b..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AdjustedType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AdjustedType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1525]) || tp >= &(gTypes[1526])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AdjustedType::static_kind():
-      tp = &(gTypes[1525]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AdjustedType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AdjustedType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AdjustedType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1525]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AdjustedType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AdjustedType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AdjustedType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AdjustedType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AdjustedType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AliasAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AliasAttr.cpp
deleted file mode 100644
index 1c6e64a3a..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AliasAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AliasAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[942]) || tp >= &(gTypes[943])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AliasAttr::static_kind():
-      tp = &(gTypes[942]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AliasAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AliasAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AliasAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[942]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AliasAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AliasAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AliasAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AliasAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AliasAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AlignOfExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/AlignOfExprOp.cpp
deleted file mode 100644
index bebd6f7ee..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AlignOfExprOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AlignOfExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1328]) || tp >= &(gTypes[1329])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AlignOfExprOp::static_kind():
-      tp = &(gTypes[1328]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AlignOfExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfExprOp::result"),
-    nullptr,
-  },
-  {
-    "expression",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->expression());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfExprOp::expression"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1328]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AlignOfExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AlignOfExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AlignOfExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AlignOfExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AlignOfExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AlignOfTypeOp.cpp b/bindings/Python/Generated/IR/HighLevel/AlignOfTypeOp.cpp
deleted file mode 100644
index ac257e796..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AlignOfTypeOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AlignOfTypeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1329]) || tp >= &(gTypes[1330])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AlignOfTypeOp::static_kind():
-      tp = &(gTypes[1329]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AlignOfTypeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfTypeOp::result"),
-    nullptr,
-  },
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfTypeOp::argument"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfTypeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfTypeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignOfTypeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1329]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AlignOfTypeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AlignOfTypeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AlignOfTypeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AlignOfTypeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AlignOfTypeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AlignedAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AlignedAttr.cpp
deleted file mode 100644
index 5ac15a76f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AlignedAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AlignedAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[946]) || tp >= &(gTypes[947])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AlignedAttr::static_kind():
-      tp = &(gTypes[946]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AlignedAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignedAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlignedAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[946]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AlignedAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AlignedAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AlignedAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AlignedAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AlignedAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AllocAlignAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AllocAlignAttr.cpp
deleted file mode 100644
index 4b8888684..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AllocAlignAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AllocAlignAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[974]) || tp >= &(gTypes[975])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AllocAlignAttr::static_kind():
-      tp = &(gTypes[974]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AllocAlignAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AllocAlignAttr::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AllocAlignAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AllocAlignAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[974]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AllocAlignAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AllocAlignAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AllocAlignAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AllocAlignAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AllocAlignAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AllocSizeAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AllocSizeAttr.cpp
deleted file mode 100644
index cb3d303a9..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AllocSizeAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AllocSizeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[975]) || tp >= &(gTypes[976])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AllocSizeAttr::static_kind():
-      tp = &(gTypes[975]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AllocSizeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "size_arg_pos",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size_arg_pos());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AllocSizeAttr::size_arg_pos"),
-    nullptr,
-  },
-  {
-    "num_arg_pos",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_arg_pos());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AllocSizeAttr::num_arg_pos"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AllocSizeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AllocSizeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[975]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AllocSizeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AllocSizeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AllocSizeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AllocSizeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AllocSizeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AlwaysInlineAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AlwaysInlineAttr.cpp
deleted file mode 100644
index a1edcd1b5..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AlwaysInlineAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AlwaysInlineAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[947]) || tp >= &(gTypes[948])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AlwaysInlineAttr::static_kind():
-      tp = &(gTypes[947]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AlwaysInlineAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlwaysInlineAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AlwaysInlineAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[947]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AlwaysInlineAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AlwaysInlineAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AlwaysInlineAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AlwaysInlineAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AlwaysInlineAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AnnotationAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AnnotationAttr.cpp
deleted file mode 100644
index f66e4c14f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AnnotationAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AnnotationAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[939]) || tp >= &(gTypes[940])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AnnotationAttr::static_kind():
-      tp = &(gTypes[939]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AnnotationAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AnnotationAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AnnotationAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[939]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AnnotationAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AnnotationAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AnnotationAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AnnotationAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AnnotationAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ArrayType.cpp b/bindings/Python/Generated/IR/HighLevel/ArrayType.cpp
deleted file mode 100644
index 47ff79453..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ArrayType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ArrayType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1521]) || tp >= &(gTypes[1522])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ArrayType::static_kind():
-      tp = &(gTypes[1521]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ArrayType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ArrayType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ArrayType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1521]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ArrayType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ArrayType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ArrayType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ArrayType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ArrayType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AsmLabelAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AsmLabelAttr.cpp
deleted file mode 100644
index 564e0920a..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AsmLabelAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AsmLabelAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[971]) || tp >= &(gTypes[972])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AsmLabelAttr::static_kind():
-      tp = &(gTypes[971]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AsmLabelAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_literal",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_literal());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmLabelAttr::is_literal"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmLabelAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmLabelAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[971]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AsmLabelAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AsmLabelAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AsmLabelAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AsmLabelAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AsmLabelAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AsmOp.cpp b/bindings/Python/Generated/IR/HighLevel/AsmOp.cpp
deleted file mode 100644
index c46a71a14..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AsmOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AsmOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1330]) || tp >= &(gTypes[1331])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AsmOp::static_kind():
-      tp = &(gTypes[1330]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AsmOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "asm_outputs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::asm_outputs);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmOp::asm_outputs"),
-    nullptr,
-  },
-  {
-    "asm_inputs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::asm_inputs);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmOp::asm_inputs"),
-    nullptr,
-  },
-  {
-    "labels",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::labels);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmOp::labels"),
-    nullptr,
-  },
-  {
-    "asm_template",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->asm_template());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmOp::asm_template"),
-    nullptr,
-  },
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmOp::is_volatile"),
-    nullptr,
-  },
-  {
-    "has_goto",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->has_goto());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmOp::has_goto"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AsmOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1330]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AsmOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AsmOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AsmOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AsmOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AsmOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/AssignOp.cpp
deleted file mode 100644
index 31b86e66b..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1331]) || tp >= &(gTypes[1332])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AssignOp::static_kind():
-      tp = &(gTypes[1331]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1331]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AssumeAlignedAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AssumeAlignedAttr.cpp
deleted file mode 100644
index 921f3cbc4..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AssumeAlignedAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AssumeAlignedAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[979]) || tp >= &(gTypes[980])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AssumeAlignedAttr::static_kind():
-      tp = &(gTypes[979]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AssumeAlignedAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AssumeAlignedAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AssumeAlignedAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[979]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AssumeAlignedAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AssumeAlignedAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AssumeAlignedAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AssumeAlignedAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AssumeAlignedAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AtomicType.cpp b/bindings/Python/Generated/IR/HighLevel/AtomicType.cpp
deleted file mode 100644
index ef80c01ee..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AtomicType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AtomicType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1530]) || tp >= &(gTypes[1531])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AtomicType::static_kind():
-      tp = &(gTypes[1530]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AtomicType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AtomicType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AtomicType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1530]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AtomicType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AtomicType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AtomicType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AtomicType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AtomicType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/Attribute.cpp b/bindings/Python/Generated/IR/HighLevel/Attribute.cpp
deleted file mode 100644
index 232449ae6..000000000
--- a/bindings/Python/Generated/IR/HighLevel/Attribute.cpp
+++ /dev/null
@@ -1,393 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::Attribute;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[938]) || tp >= &(gTypes[984])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AnnotationAttr::static_kind():
-      tp = &(gTypes[939]);
-      break;
-
-    case mx::ir::hl::FormatAttr::static_kind():
-      tp = &(gTypes[940]);
-      break;
-
-    case mx::ir::hl::SectionAttr::static_kind():
-      tp = &(gTypes[941]);
-      break;
-
-    case mx::ir::hl::AliasAttr::static_kind():
-      tp = &(gTypes[942]);
-      break;
-
-    case mx::ir::hl::ErrorAttr::static_kind():
-      tp = &(gTypes[943]);
-      break;
-
-    case mx::ir::hl::CountedByAttr::static_kind():
-      tp = &(gTypes[944]);
-      break;
-
-    case mx::ir::hl::CleanupAttr::static_kind():
-      tp = &(gTypes[945]);
-      break;
-
-    case mx::ir::hl::AlignedAttr::static_kind():
-      tp = &(gTypes[946]);
-      break;
-
-    case mx::ir::hl::AlwaysInlineAttr::static_kind():
-      tp = &(gTypes[947]);
-      break;
-
-    case mx::ir::hl::NoInlineAttr::static_kind():
-      tp = &(gTypes[948]);
-      break;
-
-    case mx::ir::hl::ConstAttr::static_kind():
-      tp = &(gTypes[949]);
-      break;
-
-    case mx::ir::hl::LoaderUninitializedAttr::static_kind():
-      tp = &(gTypes[950]);
-      break;
-
-    case mx::ir::hl::NoInstrumentFunctionAttr::static_kind():
-      tp = &(gTypes[951]);
-      break;
-
-    case mx::ir::hl::PackedAttr::static_kind():
-      tp = &(gTypes[952]);
-      break;
-
-    case mx::ir::hl::PureAttr::static_kind():
-      tp = &(gTypes[953]);
-      break;
-
-    case mx::ir::hl::WarnUnusedResultAttr::static_kind():
-      tp = &(gTypes[954]);
-      break;
-
-    case mx::ir::hl::RestrictAttr::static_kind():
-      tp = &(gTypes[955]);
-      break;
-
-    case mx::ir::hl::NoThrowAttr::static_kind():
-      tp = &(gTypes[956]);
-      break;
-
-    case mx::ir::hl::NonNullAttr::static_kind():
-      tp = &(gTypes[957]);
-      break;
-
-    case mx::ir::hl::LeafAttr::static_kind():
-      tp = &(gTypes[958]);
-      break;
-
-    case mx::ir::hl::ColdAttr::static_kind():
-      tp = &(gTypes[959]);
-      break;
-
-    case mx::ir::hl::TransparentUnionAttr::static_kind():
-      tp = &(gTypes[960]);
-      break;
-
-    case mx::ir::hl::ReturnsTwiceAttr::static_kind():
-      tp = &(gTypes[961]);
-      break;
-
-    case mx::ir::hl::MayAliasAttr::static_kind():
-      tp = &(gTypes[962]);
-      break;
-
-    case mx::ir::hl::UnusedAttr::static_kind():
-      tp = &(gTypes[963]);
-      break;
-
-    case mx::ir::hl::UsedAttr::static_kind():
-      tp = &(gTypes[964]);
-      break;
-
-    case mx::ir::hl::GNUInlineAttr::static_kind():
-      tp = &(gTypes[965]);
-      break;
-
-    case mx::ir::hl::NoCfCheckAttr::static_kind():
-      tp = &(gTypes[966]);
-      break;
-
-    case mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr::static_kind():
-      tp = &(gTypes[967]);
-      break;
-
-    case mx::ir::hl::AvailabilityAttrAttr::static_kind():
-      tp = &(gTypes[968]);
-      break;
-
-    case mx::ir::hl::FallthroughAttr::static_kind():
-      tp = &(gTypes[969]);
-      break;
-
-    case mx::ir::hl::NoProfileInstrumentFunctionAttr::static_kind():
-      tp = &(gTypes[970]);
-      break;
-
-    case mx::ir::hl::AsmLabelAttr::static_kind():
-      tp = &(gTypes[971]);
-      break;
-
-    case mx::ir::hl::ModeAttr::static_kind():
-      tp = &(gTypes[972]);
-      break;
-
-    case mx::ir::hl::BuiltinAttr::static_kind():
-      tp = &(gTypes[973]);
-      break;
-
-    case mx::ir::hl::AllocAlignAttr::static_kind():
-      tp = &(gTypes[974]);
-      break;
-
-    case mx::ir::hl::AllocSizeAttr::static_kind():
-      tp = &(gTypes[975]);
-      break;
-
-    case mx::ir::hl::DeprecatedAttr::static_kind():
-      tp = &(gTypes[976]);
-      break;
-
-    case mx::ir::hl::MaxFieldAlignmentAttr::static_kind():
-      tp = &(gTypes[977]);
-      break;
-
-    case mx::ir::hl::VisibilityAttr::static_kind():
-      tp = &(gTypes[978]);
-      break;
-
-    case mx::ir::hl::AssumeAlignedAttr::static_kind():
-      tp = &(gTypes[979]);
-      break;
-
-    case mx::ir::hl::CVQualifiersAttr::static_kind():
-      tp = &(gTypes[980]);
-      break;
-
-    case mx::ir::hl::UCVQualifiersAttr::static_kind():
-      tp = &(gTypes[981]);
-      break;
-
-    case mx::ir::hl::CVRQualifiersAttr::static_kind():
-      tp = &(gTypes[982]);
-      break;
-
-    case mx::ir::hl::OffsetOfNodeAttr::static_kind():
-      tp = &(gTypes[983]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Attribute", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::Attribute::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[938]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.Attribute";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::Attribute");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[867].tp_hash;
-  tp->tp_richcompare = gTypes[867].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[867]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Attribute.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Attribute.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Attribute' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AttributedStmtOp.cpp b/bindings/Python/Generated/IR/HighLevel/AttributedStmtOp.cpp
deleted file mode 100644
index e30dd2a42..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AttributedStmtOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AttributedStmtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1332]) || tp >= &(gTypes[1333])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AttributedStmtOp::static_kind():
-      tp = &(gTypes[1332]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AttributedStmtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::AttributedStmtOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AttributedStmtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AttributedStmtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AttributedStmtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1332]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AttributedStmtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AttributedStmtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AttributedStmtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AttributedStmtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AttributedStmtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AttributedType.cpp b/bindings/Python/Generated/IR/HighLevel/AttributedType.cpp
deleted file mode 100644
index 0d7b277f2..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AttributedType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AttributedType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1524]) || tp >= &(gTypes[1525])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AttributedType::static_kind():
-      tp = &(gTypes[1524]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AttributedType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AttributedType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AttributedType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1524]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AttributedType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AttributedType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AttributedType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AttributedType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AttributedType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AutoType.cpp b/bindings/Python/Generated/IR/HighLevel/AutoType.cpp
deleted file mode 100644
index a4ad41668..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AutoType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AutoType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1529]) || tp >= &(gTypes[1530])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AutoType::static_kind():
-      tp = &(gTypes[1529]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AutoType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AutoType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AutoType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1529]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AutoType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AutoType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AutoType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AutoType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AutoType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AvailabilityAttrAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AvailabilityAttrAttr.cpp
deleted file mode 100644
index 010630175..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AvailabilityAttrAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AvailabilityAttrAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[968]) || tp >= &(gTypes[969])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AvailabilityAttrAttr::static_kind():
-      tp = &(gTypes[968]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AvailabilityAttrAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AvailabilityAttrAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AvailabilityAttrAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[968]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AvailabilityAttrAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AvailabilityAttrAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AvailabilityAttrAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AvailabilityAttrAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AvailabilityAttrAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/AvailableOnlyInDefaultEvalMethodAttr.cpp b/bindings/Python/Generated/IR/HighLevel/AvailableOnlyInDefaultEvalMethodAttr.cpp
deleted file mode 100644
index b8cbdb6d5..000000000
--- a/bindings/Python/Generated/IR/HighLevel/AvailableOnlyInDefaultEvalMethodAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[967]) || tp >= &(gTypes[968])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr::static_kind():
-      tp = &(gTypes[967]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AvailableOnlyInDefaultEvalMethodAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[967]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.AvailableOnlyInDefaultEvalMethodAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::AvailableOnlyInDefaultEvalMethodAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AvailableOnlyInDefaultEvalMethodAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AvailableOnlyInDefaultEvalMethodAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AvailableOnlyInDefaultEvalMethodAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BFloat16Type.cpp b/bindings/Python/Generated/IR/HighLevel/BFloat16Type.cpp
deleted file mode 100644
index 5a28f4ab1..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BFloat16Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BFloat16Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1514]) || tp >= &(gTypes[1515])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BFloat16Type::static_kind():
-      tp = &(gTypes[1514]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BFloat16Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BFloat16Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BFloat16Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1514]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BFloat16Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BFloat16Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BFloat16Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BFloat16Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BFloat16Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinAShrAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinAShrAssignOp.cpp
deleted file mode 100644
index a80a5be4a..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinAShrAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinAShrAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1333]) || tp >= &(gTypes[1334])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinAShrAssignOp::static_kind():
-      tp = &(gTypes[1333]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinAShrAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1333]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinAShrAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinAShrAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinAShrAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinAShrAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinAShrAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinAShrOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinAShrOp.cpp
deleted file mode 100644
index d4da52ef8..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinAShrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinAShrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1334]) || tp >= &(gTypes[1335])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinAShrOp::static_kind():
-      tp = &(gTypes[1334]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinAShrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAShrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1334]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinAShrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinAShrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinAShrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinAShrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinAShrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinAndAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinAndAssignOp.cpp
deleted file mode 100644
index 91949c7ee..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinAndAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinAndAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1335]) || tp >= &(gTypes[1336])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinAndAssignOp::static_kind():
-      tp = &(gTypes[1335]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinAndAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1335]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinAndAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinAndAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinAndAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinAndAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinAndAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinAndOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinAndOp.cpp
deleted file mode 100644
index 970f99445..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinAndOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinAndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1336]) || tp >= &(gTypes[1337])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinAndOp::static_kind():
-      tp = &(gTypes[1336]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinAndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinAndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1336]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinAndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinAndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinAndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinAndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinAndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinCommaOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinCommaOp.cpp
deleted file mode 100644
index 15e23c26c..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinCommaOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinCommaOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1337]) || tp >= &(gTypes[1338])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinCommaOp::static_kind():
-      tp = &(gTypes[1337]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinCommaOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinCommaOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinCommaOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinCommaOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinCommaOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinCommaOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinCommaOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1337]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinCommaOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinCommaOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinCommaOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinCommaOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinCommaOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinLAndOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinLAndOp.cpp
deleted file mode 100644
index 8c5fdc982..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinLAndOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinLAndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1338]) || tp >= &(gTypes[1339])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinLAndOp::static_kind():
-      tp = &(gTypes[1338]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinLAndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLAndOp::result"),
-    nullptr,
-  },
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLAndOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLAndOp::right"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLAndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLAndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLAndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1338]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinLAndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinLAndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinLAndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinLAndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinLAndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinLOrOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinLOrOp.cpp
deleted file mode 100644
index c6e039e59..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinLOrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinLOrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1339]) || tp >= &(gTypes[1340])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinLOrOp::static_kind():
-      tp = &(gTypes[1339]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinLOrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLOrOp::result"),
-    nullptr,
-  },
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLOrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLOrOp::right"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLOrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLOrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLOrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1339]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinLOrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinLOrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinLOrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinLOrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinLOrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinLShrAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinLShrAssignOp.cpp
deleted file mode 100644
index b157987b7..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinLShrAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinLShrAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1340]) || tp >= &(gTypes[1341])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinLShrAssignOp::static_kind():
-      tp = &(gTypes[1340]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinLShrAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1340]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinLShrAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinLShrAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinLShrAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinLShrAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinLShrAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinLShrOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinLShrOp.cpp
deleted file mode 100644
index 6f4177f48..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinLShrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinLShrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1341]) || tp >= &(gTypes[1342])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinLShrOp::static_kind():
-      tp = &(gTypes[1341]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinLShrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinLShrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1341]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinLShrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinLShrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinLShrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinLShrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinLShrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinOrAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinOrAssignOp.cpp
deleted file mode 100644
index 0006eb97f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinOrAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinOrAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1342]) || tp >= &(gTypes[1343])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinOrAssignOp::static_kind():
-      tp = &(gTypes[1342]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinOrAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1342]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinOrAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinOrAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinOrAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinOrAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinOrAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinOrOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinOrOp.cpp
deleted file mode 100644
index b17b65e2e..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinOrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinOrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1343]) || tp >= &(gTypes[1344])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinOrOp::static_kind():
-      tp = &(gTypes[1343]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinOrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinOrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1343]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinOrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinOrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinOrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinOrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinOrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinShlAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinShlAssignOp.cpp
deleted file mode 100644
index 5a38e15eb..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinShlAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinShlAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1344]) || tp >= &(gTypes[1345])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinShlAssignOp::static_kind():
-      tp = &(gTypes[1344]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinShlAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1344]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinShlAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinShlAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinShlAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinShlAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinShlAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinShlOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinShlOp.cpp
deleted file mode 100644
index dd687244e..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinShlOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinShlOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1345]) || tp >= &(gTypes[1346])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinShlOp::static_kind():
-      tp = &(gTypes[1345]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinShlOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinShlOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1345]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinShlOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinShlOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinShlOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinShlOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinShlOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinXorAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinXorAssignOp.cpp
deleted file mode 100644
index e7825215b..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinXorAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinXorAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1346]) || tp >= &(gTypes[1347])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinXorAssignOp::static_kind():
-      tp = &(gTypes[1346]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinXorAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1346]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinXorAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinXorAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinXorAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinXorAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinXorAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinXorOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinXorOp.cpp
deleted file mode 100644
index c4c5a9e3f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinXorOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinXorOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1347]) || tp >= &(gTypes[1348])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinXorOp::static_kind():
-      tp = &(gTypes[1347]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinXorOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinXorOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1347]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinXorOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinXorOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinXorOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinXorOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinXorOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BinaryCondOp.cpp b/bindings/Python/Generated/IR/HighLevel/BinaryCondOp.cpp
deleted file mode 100644
index 986462bca..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BinaryCondOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BinaryCondOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1348]) || tp >= &(gTypes[1349])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BinaryCondOp::static_kind():
-      tp = &(gTypes[1348]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BinaryCondOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinaryCondOp::result"),
-    nullptr,
-  },
-  {
-    "common_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->common_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinaryCondOp::common_region"),
-    nullptr,
-  },
-  {
-    "condition_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->condition_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinaryCondOp::condition_region"),
-    nullptr,
-  },
-  {
-    "then_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->then_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinaryCondOp::then_region"),
-    nullptr,
-  },
-  {
-    "else_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->else_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinaryCondOp::else_region"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinaryCondOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinaryCondOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BinaryCondOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1348]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BinaryCondOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BinaryCondOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BinaryCondOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BinaryCondOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BinaryCondOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BoolType.cpp b/bindings/Python/Generated/IR/HighLevel/BoolType.cpp
deleted file mode 100644
index fdb75c17c..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BoolType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BoolType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1506]) || tp >= &(gTypes[1507])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BoolType::static_kind():
-      tp = &(gTypes[1506]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BoolType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BoolType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BoolType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1506]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BoolType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BoolType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BoolType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BoolType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BoolType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BreakOp.cpp b/bindings/Python/Generated/IR/HighLevel/BreakOp.cpp
deleted file mode 100644
index 0d20362eb..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BreakOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BreakOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1349]) || tp >= &(gTypes[1350])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BreakOp::static_kind():
-      tp = &(gTypes[1349]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BreakOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BreakOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BreakOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BreakOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1349]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BreakOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BreakOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BreakOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BreakOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BreakOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BuiltinAttr.cpp b/bindings/Python/Generated/IR/HighLevel/BuiltinAttr.cpp
deleted file mode 100644
index 62e9a0196..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BuiltinAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BuiltinAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[973]) || tp >= &(gTypes[974])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BuiltinAttr::static_kind():
-      tp = &(gTypes[973]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BuiltinAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "id",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->id());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinAttr::id"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[973]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BuiltinAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BuiltinAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BuiltinAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BuiltinAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BuiltinAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BuiltinBitCastOp.cpp b/bindings/Python/Generated/IR/HighLevel/BuiltinBitCastOp.cpp
deleted file mode 100644
index f0ddea634..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BuiltinBitCastOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BuiltinBitCastOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1350]) || tp >= &(gTypes[1351])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BuiltinBitCastOp::static_kind():
-      tp = &(gTypes[1350]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BuiltinBitCastOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinBitCastOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinBitCastOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinBitCastOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinBitCastOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinBitCastOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1350]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BuiltinBitCastOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BuiltinBitCastOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BuiltinBitCastOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BuiltinBitCastOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BuiltinBitCastOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/BuiltinTypesCompatiblePOp.cpp b/bindings/Python/Generated/IR/HighLevel/BuiltinTypesCompatiblePOp.cpp
deleted file mode 100644
index 25d3942bd..000000000
--- a/bindings/Python/Generated/IR/HighLevel/BuiltinTypesCompatiblePOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::BuiltinTypesCompatiblePOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1351]) || tp >= &(gTypes[1352])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::BuiltinTypesCompatiblePOp::static_kind():
-      tp = &(gTypes[1351]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BuiltinTypesCompatiblePOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinTypesCompatiblePOp::result"),
-    nullptr,
-  },
-  {
-    "type1",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type1());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinTypesCompatiblePOp::type1"),
-    nullptr,
-  },
-  {
-    "type2",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type2());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinTypesCompatiblePOp::type2"),
-    nullptr,
-  },
-  {
-    "compatible",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->compatible());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinTypesCompatiblePOp::compatible"),
-    nullptr,
-  },
-  {
-    "arguments",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arguments);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinTypesCompatiblePOp::arguments"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinTypesCompatiblePOp::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinTypesCompatiblePOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinTypesCompatiblePOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::BuiltinTypesCompatiblePOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1351]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.BuiltinTypesCompatiblePOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::BuiltinTypesCompatiblePOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BuiltinTypesCompatiblePOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BuiltinTypesCompatiblePOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BuiltinTypesCompatiblePOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CStyleCastOp.cpp b/bindings/Python/Generated/IR/HighLevel/CStyleCastOp.cpp
deleted file mode 100644
index 922a52df6..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CStyleCastOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CStyleCastOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1352]) || tp >= &(gTypes[1353])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CStyleCastOp::static_kind():
-      tp = &(gTypes[1352]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CStyleCastOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CStyleCastOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CStyleCastOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CStyleCastOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CStyleCastOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CStyleCastOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1352]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CStyleCastOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CStyleCastOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CStyleCastOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CStyleCastOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CStyleCastOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CVQualifiersAttr.cpp b/bindings/Python/Generated/IR/HighLevel/CVQualifiersAttr.cpp
deleted file mode 100644
index 55fe49bd7..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CVQualifiersAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CVQualifiersAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[980]) || tp >= &(gTypes[981])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CVQualifiersAttr::static_kind():
-      tp = &(gTypes[980]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CVQualifiersAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_const",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_const());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CVQualifiersAttr::is_const"),
-    nullptr,
-  },
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CVQualifiersAttr::is_volatile"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CVQualifiersAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CVQualifiersAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[980]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CVQualifiersAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CVQualifiersAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CVQualifiersAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CVQualifiersAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CVQualifiersAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CVRQualifiersAttr.cpp b/bindings/Python/Generated/IR/HighLevel/CVRQualifiersAttr.cpp
deleted file mode 100644
index 9ab304857..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CVRQualifiersAttr.cpp
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CVRQualifiersAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[982]) || tp >= &(gTypes[983])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CVRQualifiersAttr::static_kind():
-      tp = &(gTypes[982]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CVRQualifiersAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_const",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_const());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CVRQualifiersAttr::is_const"),
-    nullptr,
-  },
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CVRQualifiersAttr::is_volatile"),
-    nullptr,
-  },
-  {
-    "is_restrict",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_restrict());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CVRQualifiersAttr::is_restrict"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CVRQualifiersAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CVRQualifiersAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[982]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CVRQualifiersAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CVRQualifiersAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CVRQualifiersAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CVRQualifiersAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CVRQualifiersAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CallOp.cpp b/bindings/Python/Generated/IR/HighLevel/CallOp.cpp
deleted file mode 100644
index 01cd6ef61..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CallOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CallOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1353]) || tp >= &(gTypes[1354])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CallOp::static_kind():
-      tp = &(gTypes[1353]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CallOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "arg_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arg_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CallOp::arg_operands"),
-    nullptr,
-  },
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CallOp::results"),
-    nullptr,
-  },
-  {
-    "callee",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->callee());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CallOp::callee"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CallOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CallOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CallOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1353]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CallOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CallOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CallOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CallOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CallOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CaseOp.cpp b/bindings/Python/Generated/IR/HighLevel/CaseOp.cpp
deleted file mode 100644
index 55fa84601..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CaseOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CaseOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1354]) || tp >= &(gTypes[1355])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CaseOp::static_kind():
-      tp = &(gTypes[1354]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CaseOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CaseOp::left"),
-    nullptr,
-  },
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CaseOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CaseOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CaseOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CaseOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1354]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CaseOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CaseOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CaseOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CaseOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CaseOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CharType.cpp b/bindings/Python/Generated/IR/HighLevel/CharType.cpp
deleted file mode 100644
index c8cf1662d..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CharType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CharType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1507]) || tp >= &(gTypes[1508])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CharType::static_kind():
-      tp = &(gTypes[1507]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CharType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CharType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CharType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1507]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CharType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CharType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CharType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CharType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CharType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ChooseExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/ChooseExprOp.cpp
deleted file mode 100644
index 73251f89e..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ChooseExprOp.cpp
+++ /dev/null
@@ -1,325 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ChooseExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1355]) || tp >= &(gTypes[1356])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ChooseExprOp::static_kind():
-      tp = &(gTypes[1355]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ChooseExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::result"),
-    nullptr,
-  },
-  {
-    "condition_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->condition_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::condition_region"),
-    nullptr,
-  },
-  {
-    "then_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->then_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::then_region"),
-    nullptr,
-  },
-  {
-    "else_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->else_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::else_region"),
-    nullptr,
-  },
-  {
-    "cond_true",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->cond_true());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::cond_true"),
-    nullptr,
-  },
-  {
-    "is_condition_true",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_condition_true());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::is_condition_true"),
-    nullptr,
-  },
-  {
-    "is_condition_dependent",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_condition_dependent());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::is_condition_dependent"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ChooseExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1355]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ChooseExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ChooseExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ChooseExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ChooseExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ChooseExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ClassDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/ClassDeclOp.cpp
deleted file mode 100644
index f187c9b79..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ClassDeclOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ClassDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1356]) || tp >= &(gTypes[1357])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ClassDeclOp::static_kind():
-      tp = &(gTypes[1356]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ClassDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "bases",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->bases());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ClassDeclOp::bases"),
-    nullptr,
-  },
-  {
-    "fields",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->fields());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ClassDeclOp::fields"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ClassDeclOp::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ClassDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ClassDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ClassDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1356]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ClassDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ClassDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ClassDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ClassDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ClassDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CleanupAttr.cpp b/bindings/Python/Generated/IR/HighLevel/CleanupAttr.cpp
deleted file mode 100644
index 0a6483aba..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CleanupAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CleanupAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[945]) || tp >= &(gTypes[946])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CleanupAttr::static_kind():
-      tp = &(gTypes[945]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CleanupAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CleanupAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CleanupAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[945]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CleanupAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CleanupAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CleanupAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CleanupAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CleanupAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CmpOp.cpp b/bindings/Python/Generated/IR/HighLevel/CmpOp.cpp
deleted file mode 100644
index dfc499eb4..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CmpOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CmpOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1357]) || tp >= &(gTypes[1358])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CmpOp::static_kind():
-      tp = &(gTypes[1357]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CmpOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CmpOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CmpOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CmpOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CmpOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CmpOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CmpOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1357]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CmpOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CmpOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CmpOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CmpOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CmpOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ColdAttr.cpp b/bindings/Python/Generated/IR/HighLevel/ColdAttr.cpp
deleted file mode 100644
index 9c90932ca..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ColdAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ColdAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[959]) || tp >= &(gTypes[960])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ColdAttr::static_kind():
-      tp = &(gTypes[959]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ColdAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ColdAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ColdAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[959]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ColdAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ColdAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ColdAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ColdAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ColdAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ComplexType.cpp b/bindings/Python/Generated/IR/HighLevel/ComplexType.cpp
deleted file mode 100644
index 7f50095b4..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ComplexType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ComplexType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1519]) || tp >= &(gTypes[1520])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ComplexType::static_kind():
-      tp = &(gTypes[1519]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ComplexType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ComplexType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ComplexType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1519]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ComplexType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ComplexType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ComplexType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ComplexType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ComplexType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CompoundLiteralOp.cpp b/bindings/Python/Generated/IR/HighLevel/CompoundLiteralOp.cpp
deleted file mode 100644
index f54c32325..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CompoundLiteralOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CompoundLiteralOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1358]) || tp >= &(gTypes[1359])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CompoundLiteralOp::static_kind():
-      tp = &(gTypes[1358]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CompoundLiteralOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CompoundLiteralOp::result"),
-    nullptr,
-  },
-  {
-    "initializer",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->initializer());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CompoundLiteralOp::initializer"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CompoundLiteralOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CompoundLiteralOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CompoundLiteralOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1358]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CompoundLiteralOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CompoundLiteralOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CompoundLiteralOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CompoundLiteralOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CompoundLiteralOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CondOp.cpp b/bindings/Python/Generated/IR/HighLevel/CondOp.cpp
deleted file mode 100644
index 288d222ee..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CondOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CondOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1359]) || tp >= &(gTypes[1360])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CondOp::static_kind():
-      tp = &(gTypes[1359]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CondOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondOp::result"),
-    nullptr,
-  },
-  {
-    "condition_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->condition_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondOp::condition_region"),
-    nullptr,
-  },
-  {
-    "then_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->then_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondOp::then_region"),
-    nullptr,
-  },
-  {
-    "else_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->else_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondOp::else_region"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1359]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CondOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CondOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CondOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CondOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CondOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CondYieldOp.cpp b/bindings/Python/Generated/IR/HighLevel/CondYieldOp.cpp
deleted file mode 100644
index dbb4588fc..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CondYieldOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CondYieldOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1360]) || tp >= &(gTypes[1361])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CondYieldOp::static_kind():
-      tp = &(gTypes[1360]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CondYieldOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondYieldOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondYieldOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondYieldOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CondYieldOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1360]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CondYieldOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CondYieldOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CondYieldOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CondYieldOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CondYieldOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ConstAttr.cpp b/bindings/Python/Generated/IR/HighLevel/ConstAttr.cpp
deleted file mode 100644
index 739cc304f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ConstAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ConstAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[949]) || tp >= &(gTypes[950])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ConstAttr::static_kind():
-      tp = &(gTypes[949]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ConstAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ConstAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ConstAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[949]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ConstAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ConstAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ConstAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ConstAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ConstAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ConstantOp.cpp b/bindings/Python/Generated/IR/HighLevel/ConstantOp.cpp
deleted file mode 100644
index 1f380839e..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ConstantOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ConstantOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1361]) || tp >= &(gTypes[1362])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ConstantOp::static_kind():
-      tp = &(gTypes[1361]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ConstantOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ConstantOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ConstantOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ConstantOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ConstantOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1361]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ConstantOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ConstantOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ConstantOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ConstantOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ConstantOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ContinueOp.cpp b/bindings/Python/Generated/IR/HighLevel/ContinueOp.cpp
deleted file mode 100644
index f3cf3d54c..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ContinueOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ContinueOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1362]) || tp >= &(gTypes[1363])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ContinueOp::static_kind():
-      tp = &(gTypes[1362]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ContinueOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ContinueOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ContinueOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ContinueOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1362]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ContinueOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ContinueOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ContinueOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ContinueOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ContinueOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CountedByAttr.cpp b/bindings/Python/Generated/IR/HighLevel/CountedByAttr.cpp
deleted file mode 100644
index af5fd58ca..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CountedByAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CountedByAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[944]) || tp >= &(gTypes[945])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CountedByAttr::static_kind():
-      tp = &(gTypes[944]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CountedByAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CountedByAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CountedByAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[944]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CountedByAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CountedByAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CountedByAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CountedByAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CountedByAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CxxBaseSpecifierOp.cpp b/bindings/Python/Generated/IR/HighLevel/CxxBaseSpecifierOp.cpp
deleted file mode 100644
index 5459d0651..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CxxBaseSpecifierOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CxxBaseSpecifierOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1363]) || tp >= &(gTypes[1364])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CxxBaseSpecifierOp::static_kind():
-      tp = &(gTypes[1363]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CxxBaseSpecifierOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxBaseSpecifierOp::type"),
-    nullptr,
-  },
-  {
-    "is_virtual",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_virtual());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxBaseSpecifierOp::is_virtual"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxBaseSpecifierOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxBaseSpecifierOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxBaseSpecifierOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1363]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CxxBaseSpecifierOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CxxBaseSpecifierOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CxxBaseSpecifierOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CxxBaseSpecifierOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CxxBaseSpecifierOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/CxxStructDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/CxxStructDeclOp.cpp
deleted file mode 100644
index 1939876a1..000000000
--- a/bindings/Python/Generated/IR/HighLevel/CxxStructDeclOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::CxxStructDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1364]) || tp >= &(gTypes[1365])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::CxxStructDeclOp::static_kind():
-      tp = &(gTypes[1364]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CxxStructDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "bases",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->bases());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxStructDeclOp::bases"),
-    nullptr,
-  },
-  {
-    "fields",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->fields());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxStructDeclOp::fields"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxStructDeclOp::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxStructDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxStructDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::CxxStructDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1364]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.CxxStructDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::CxxStructDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CxxStructDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CxxStructDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CxxStructDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DecayedType.cpp b/bindings/Python/Generated/IR/HighLevel/DecayedType.cpp
deleted file mode 100644
index 736aa7f81..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DecayedType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DecayedType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1523]) || tp >= &(gTypes[1524])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DecayedType::static_kind():
-      tp = &(gTypes[1523]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DecayedType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DecayedType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DecayedType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1523]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DecayedType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DecayedType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DecayedType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DecayedType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DecayedType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DeclRefOp.cpp b/bindings/Python/Generated/IR/HighLevel/DeclRefOp.cpp
deleted file mode 100644
index 9e0490d8a..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DeclRefOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DeclRefOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1317]) || tp >= &(gTypes[1318])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DeclRefOp::static_kind():
-      tp = &(gTypes[1317]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DeclRefOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "declaration",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->declaration());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DeclRefOp::declaration"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DeclRefOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DeclRefOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DeclRefOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DeclRefOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1317]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DeclRefOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DeclRefOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1316].tp_hash;
-  tp->tp_richcompare = gTypes[1316].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1316]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DeclRefOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DeclRefOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DeclRefOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DefaultOp.cpp b/bindings/Python/Generated/IR/HighLevel/DefaultOp.cpp
deleted file mode 100644
index 41b39d175..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DefaultOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DefaultOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1365]) || tp >= &(gTypes[1366])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DefaultOp::static_kind():
-      tp = &(gTypes[1365]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DefaultOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DefaultOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DefaultOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DefaultOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DefaultOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1365]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DefaultOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DefaultOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DefaultOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DefaultOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DefaultOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DeprecatedAttr.cpp b/bindings/Python/Generated/IR/HighLevel/DeprecatedAttr.cpp
deleted file mode 100644
index 6c4f08268..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DeprecatedAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DeprecatedAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[976]) || tp >= &(gTypes[977])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DeprecatedAttr::static_kind():
-      tp = &(gTypes[976]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DeprecatedAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DeprecatedAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DeprecatedAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[976]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DeprecatedAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DeprecatedAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DeprecatedAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DeprecatedAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DeprecatedAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DerefOp.cpp b/bindings/Python/Generated/IR/HighLevel/DerefOp.cpp
deleted file mode 100644
index 1638b9f28..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DerefOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DerefOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1366]) || tp >= &(gTypes[1367])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DerefOp::static_kind():
-      tp = &(gTypes[1366]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DerefOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "addr",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->addr());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DerefOp::addr"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DerefOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DerefOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DerefOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DerefOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1366]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DerefOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DerefOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DerefOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DerefOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DerefOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DivFAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/DivFAssignOp.cpp
deleted file mode 100644
index f0007472e..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DivFAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DivFAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1367]) || tp >= &(gTypes[1368])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DivFAssignOp::static_kind():
-      tp = &(gTypes[1367]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DivFAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1367]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DivFAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DivFAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DivFAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DivFAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DivFAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DivFOp.cpp b/bindings/Python/Generated/IR/HighLevel/DivFOp.cpp
deleted file mode 100644
index aaded617d..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DivFOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DivFOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1368]) || tp >= &(gTypes[1369])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DivFOp::static_kind():
-      tp = &(gTypes[1368]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DivFOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivFOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1368]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DivFOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DivFOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DivFOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DivFOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DivFOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DivSAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/DivSAssignOp.cpp
deleted file mode 100644
index 92d65a292..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DivSAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DivSAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1369]) || tp >= &(gTypes[1370])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DivSAssignOp::static_kind():
-      tp = &(gTypes[1369]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DivSAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1369]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DivSAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DivSAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DivSAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DivSAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DivSAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DivSOp.cpp b/bindings/Python/Generated/IR/HighLevel/DivSOp.cpp
deleted file mode 100644
index bc677f7e7..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DivSOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DivSOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1370]) || tp >= &(gTypes[1371])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DivSOp::static_kind():
-      tp = &(gTypes[1370]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DivSOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivSOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1370]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DivSOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DivSOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DivSOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DivSOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DivSOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DivUAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/DivUAssignOp.cpp
deleted file mode 100644
index 2a28e9d0c..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DivUAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DivUAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1371]) || tp >= &(gTypes[1372])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DivUAssignOp::static_kind():
-      tp = &(gTypes[1371]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DivUAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1371]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DivUAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DivUAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DivUAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DivUAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DivUAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DivUOp.cpp b/bindings/Python/Generated/IR/HighLevel/DivUOp.cpp
deleted file mode 100644
index 778736b8b..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DivUOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DivUOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1372]) || tp >= &(gTypes[1373])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DivUOp::static_kind():
-      tp = &(gTypes[1372]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DivUOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DivUOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1372]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DivUOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DivUOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DivUOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DivUOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DivUOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DoOp.cpp b/bindings/Python/Generated/IR/HighLevel/DoOp.cpp
deleted file mode 100644
index 955075087..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DoOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DoOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1373]) || tp >= &(gTypes[1374])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DoOp::static_kind():
-      tp = &(gTypes[1373]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DoOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DoOp::body_region"),
-    nullptr,
-  },
-  {
-    "condition_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->condition_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::DoOp::condition_region"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DoOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DoOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DoOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1373]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DoOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DoOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DoOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DoOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DoOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/DoubleType.cpp b/bindings/Python/Generated/IR/HighLevel/DoubleType.cpp
deleted file mode 100644
index 01a5543f5..000000000
--- a/bindings/Python/Generated/IR/HighLevel/DoubleType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::DoubleType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1516]) || tp >= &(gTypes[1517])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DoubleType::static_kind():
-      tp = &(gTypes[1516]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DoubleType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DoubleType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::DoubleType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1516]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.DoubleType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::DoubleType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DoubleType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DoubleType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DoubleType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ElaboratedType.cpp b/bindings/Python/Generated/IR/HighLevel/ElaboratedType.cpp
deleted file mode 100644
index 7c56ff52d..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ElaboratedType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ElaboratedType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1500]) || tp >= &(gTypes[1501])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ElaboratedType::static_kind():
-      tp = &(gTypes[1500]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ElaboratedType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ElaboratedType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ElaboratedType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1500]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ElaboratedType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ElaboratedType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ElaboratedType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ElaboratedType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ElaboratedType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/EmptyDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/EmptyDeclOp.cpp
deleted file mode 100644
index 38ff829ce..000000000
--- a/bindings/Python/Generated/IR/HighLevel/EmptyDeclOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::EmptyDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1374]) || tp >= &(gTypes[1375])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::EmptyDeclOp::static_kind():
-      tp = &(gTypes[1374]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "EmptyDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EmptyDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EmptyDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EmptyDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1374]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.EmptyDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::EmptyDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'EmptyDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'EmptyDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'EmptyDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/EnumConstantOp.cpp b/bindings/Python/Generated/IR/HighLevel/EnumConstantOp.cpp
deleted file mode 100644
index ee72f5270..000000000
--- a/bindings/Python/Generated/IR/HighLevel/EnumConstantOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::EnumConstantOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1375]) || tp >= &(gTypes[1376])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::EnumConstantOp::static_kind():
-      tp = &(gTypes[1375]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "EnumConstantOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "initializer",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->initializer());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumConstantOp::initializer"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumConstantOp::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumConstantOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumConstantOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumConstantOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1375]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.EnumConstantOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::EnumConstantOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'EnumConstantOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'EnumConstantOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'EnumConstantOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/EnumDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/EnumDeclOp.cpp
deleted file mode 100644
index a9d7ba21b..000000000
--- a/bindings/Python/Generated/IR/HighLevel/EnumDeclOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::EnumDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1376]) || tp >= &(gTypes[1377])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::EnumDeclOp::static_kind():
-      tp = &(gTypes[1376]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "EnumDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "constants",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->constants());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumDeclOp::constants"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumDeclOp::name"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumDeclOp::type"),
-    nullptr,
-  },
-  {
-    "is_complete",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_complete());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumDeclOp::is_complete"),
-    nullptr,
-  },
-  {
-    "constants_block",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->constants_block());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumDeclOp::constants_block"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1376]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.EnumDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::EnumDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'EnumDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'EnumDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'EnumDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/EnumRefOp.cpp b/bindings/Python/Generated/IR/HighLevel/EnumRefOp.cpp
deleted file mode 100644
index 8ce517c8f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/EnumRefOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::EnumRefOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1318]) || tp >= &(gTypes[1319])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::EnumRefOp::static_kind():
-      tp = &(gTypes[1318]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "EnumRefOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumRefOp::result"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumRefOp::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumRefOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumRefOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumRefOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1318]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.EnumRefOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::EnumRefOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1316].tp_hash;
-  tp->tp_richcompare = gTypes[1316].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1316]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'EnumRefOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'EnumRefOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'EnumRefOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/EnumType.cpp b/bindings/Python/Generated/IR/HighLevel/EnumType.cpp
deleted file mode 100644
index 8e6979887..000000000
--- a/bindings/Python/Generated/IR/HighLevel/EnumType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::EnumType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1498]) || tp >= &(gTypes[1499])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::EnumType::static_kind():
-      tp = &(gTypes[1498]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "EnumType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumType::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::EnumType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1498]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.EnumType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::EnumType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'EnumType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'EnumType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'EnumType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ErrorAttr.cpp b/bindings/Python/Generated/IR/HighLevel/ErrorAttr.cpp
deleted file mode 100644
index 054c63fde..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ErrorAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ErrorAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[943]) || tp >= &(gTypes[944])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ErrorAttr::static_kind():
-      tp = &(gTypes[943]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ErrorAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ErrorAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ErrorAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[943]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ErrorAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ErrorAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ErrorAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ErrorAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ErrorAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/ExprOp.cpp
deleted file mode 100644
index ffb143a59..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ExprOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1377]) || tp >= &(gTypes[1378])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ExprOp::static_kind():
-      tp = &(gTypes[1377]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExprOp::result"),
-    nullptr,
-  },
-  {
-    "nested_expression",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->nested_expression());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExprOp::nested_expression"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1377]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ExtensionOp.cpp b/bindings/Python/Generated/IR/HighLevel/ExtensionOp.cpp
deleted file mode 100644
index f1208c37f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ExtensionOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ExtensionOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1378]) || tp >= &(gTypes[1379])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ExtensionOp::static_kind():
-      tp = &(gTypes[1378]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExtensionOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExtensionOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExtensionOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExtensionOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExtensionOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ExtensionOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1378]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ExtensionOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ExtensionOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExtensionOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExtensionOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExtensionOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/FCmpOp.cpp b/bindings/Python/Generated/IR/HighLevel/FCmpOp.cpp
deleted file mode 100644
index e559b2dd6..000000000
--- a/bindings/Python/Generated/IR/HighLevel/FCmpOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::FCmpOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1379]) || tp >= &(gTypes[1380])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::FCmpOp::static_kind():
-      tp = &(gTypes[1379]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FCmpOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FCmpOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FCmpOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FCmpOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FCmpOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FCmpOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FCmpOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1379]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.FCmpOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::FCmpOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FCmpOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FCmpOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FCmpOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/FallthroughAttr.cpp b/bindings/Python/Generated/IR/HighLevel/FallthroughAttr.cpp
deleted file mode 100644
index 256a36ca6..000000000
--- a/bindings/Python/Generated/IR/HighLevel/FallthroughAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::FallthroughAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[969]) || tp >= &(gTypes[970])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::FallthroughAttr::static_kind():
-      tp = &(gTypes[969]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FallthroughAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FallthroughAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FallthroughAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[969]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.FallthroughAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::FallthroughAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FallthroughAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FallthroughAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FallthroughAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/FieldDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/FieldDeclOp.cpp
deleted file mode 100644
index 7994fc66a..000000000
--- a/bindings/Python/Generated/IR/HighLevel/FieldDeclOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::FieldDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1380]) || tp >= &(gTypes[1381])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::FieldDeclOp::static_kind():
-      tp = &(gTypes[1380]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FieldDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FieldDeclOp::name"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FieldDeclOp::type"),
-    nullptr,
-  },
-  {
-    "bits",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->bits());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FieldDeclOp::bits"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FieldDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FieldDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FieldDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1380]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.FieldDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::FieldDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FieldDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FieldDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FieldDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/FileScopeAsmOp.cpp b/bindings/Python/Generated/IR/HighLevel/FileScopeAsmOp.cpp
deleted file mode 100644
index ff39bc571..000000000
--- a/bindings/Python/Generated/IR/HighLevel/FileScopeAsmOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::FileScopeAsmOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1381]) || tp >= &(gTypes[1382])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::FileScopeAsmOp::static_kind():
-      tp = &(gTypes[1381]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FileScopeAsmOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "assembly",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->assembly());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FileScopeAsmOp::assembly"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FileScopeAsmOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FileScopeAsmOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FileScopeAsmOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1381]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.FileScopeAsmOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::FileScopeAsmOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FileScopeAsmOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FileScopeAsmOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FileScopeAsmOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/Float128Type.cpp b/bindings/Python/Generated/IR/HighLevel/Float128Type.cpp
deleted file mode 100644
index 925abdc11..000000000
--- a/bindings/Python/Generated/IR/HighLevel/Float128Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::Float128Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1518]) || tp >= &(gTypes[1519])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::Float128Type::static_kind():
-      tp = &(gTypes[1518]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Float128Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::Float128Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::Float128Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1518]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.Float128Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::Float128Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Float128Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Float128Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Float128Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/FloatType.cpp b/bindings/Python/Generated/IR/HighLevel/FloatType.cpp
deleted file mode 100644
index 61f42ecf2..000000000
--- a/bindings/Python/Generated/IR/HighLevel/FloatType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::FloatType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1515]) || tp >= &(gTypes[1516])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::FloatType::static_kind():
-      tp = &(gTypes[1515]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FloatType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FloatType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FloatType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1515]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.FloatType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::FloatType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FloatType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FloatType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FloatType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ForOp.cpp b/bindings/Python/Generated/IR/HighLevel/ForOp.cpp
deleted file mode 100644
index 879ff6e91..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ForOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ForOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1382]) || tp >= &(gTypes[1383])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ForOp::static_kind():
-      tp = &(gTypes[1382]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ForOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "condition_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->condition_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ForOp::condition_region"),
-    nullptr,
-  },
-  {
-    "incr_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->incr_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ForOp::incr_region"),
-    nullptr,
-  },
-  {
-    "body_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ForOp::body_region"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ForOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ForOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ForOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1382]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ForOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ForOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ForOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ForOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ForOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/FormatAttr.cpp b/bindings/Python/Generated/IR/HighLevel/FormatAttr.cpp
deleted file mode 100644
index d9265f31a..000000000
--- a/bindings/Python/Generated/IR/HighLevel/FormatAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::FormatAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[940]) || tp >= &(gTypes[941])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::FormatAttr::static_kind():
-      tp = &(gTypes[940]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FormatAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FormatAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FormatAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[940]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.FormatAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::FormatAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FormatAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FormatAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FormatAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/FuncOp.cpp b/bindings/Python/Generated/IR/HighLevel/FuncOp.cpp
deleted file mode 100644
index 3594b06a0..000000000
--- a/bindings/Python/Generated/IR/HighLevel/FuncOp.cpp
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::FuncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1383]) || tp >= &(gTypes[1384])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::FuncOp::static_kind():
-      tp = &(gTypes[1383]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FuncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::body"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::name"),
-    nullptr,
-  },
-  {
-    "function_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->function_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::function_type"),
-    nullptr,
-  },
-  {
-    "visibility",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->visibility());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::visibility"),
-    nullptr,
-  },
-  {
-    "is_var_arg",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_var_arg());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::is_var_arg"),
-    nullptr,
-  },
-  {
-    "callable_results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::callable_results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::callable_results"),
-    nullptr,
-  },
-  {
-    "argument_types",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::argument_types);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::argument_types"),
-    nullptr,
-  },
-  {
-    "result_types",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::result_types);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::result_types"),
-    nullptr,
-  },
-  {
-    "is_declaration",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_declaration());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::is_declaration"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1383]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.FuncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::FuncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FuncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FuncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FuncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/FuncRefOp.cpp b/bindings/Python/Generated/IR/HighLevel/FuncRefOp.cpp
deleted file mode 100644
index 80f24fd43..000000000
--- a/bindings/Python/Generated/IR/HighLevel/FuncRefOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::FuncRefOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1319]) || tp >= &(gTypes[1320])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::FuncRefOp::static_kind():
-      tp = &(gTypes[1319]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FuncRefOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncRefOp::result"),
-    nullptr,
-  },
-  {
-    "function",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->function());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncRefOp::function"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncRefOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncRefOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::FuncRefOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1319]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.FuncRefOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::FuncRefOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1316].tp_hash;
-  tp->tp_richcompare = gTypes[1316].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1316]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FuncRefOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FuncRefOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FuncRefOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/GNUInlineAttr.cpp b/bindings/Python/Generated/IR/HighLevel/GNUInlineAttr.cpp
deleted file mode 100644
index 192edc56f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/GNUInlineAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::GNUInlineAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[965]) || tp >= &(gTypes[966])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::GNUInlineAttr::static_kind():
-      tp = &(gTypes[965]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GNUInlineAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GNUInlineAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GNUInlineAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[965]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.GNUInlineAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::GNUInlineAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GNUInlineAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GNUInlineAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GNUInlineAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/GenericAssocExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/GenericAssocExprOp.cpp
deleted file mode 100644
index 34e748c82..000000000
--- a/bindings/Python/Generated/IR/HighLevel/GenericAssocExprOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::GenericAssocExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1384]) || tp >= &(gTypes[1385])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::GenericAssocExprOp::static_kind():
-      tp = &(gTypes[1384]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GenericAssocExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericAssocExprOp::result"),
-    nullptr,
-  },
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericAssocExprOp::body"),
-    nullptr,
-  },
-  {
-    "match_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->match_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericAssocExprOp::match_type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericAssocExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericAssocExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericAssocExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1384]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.GenericAssocExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::GenericAssocExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GenericAssocExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GenericAssocExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GenericAssocExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/GenericSelectionExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/GenericSelectionExprOp.cpp
deleted file mode 100644
index c6c84a808..000000000
--- a/bindings/Python/Generated/IR/HighLevel/GenericSelectionExprOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::GenericSelectionExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1385]) || tp >= &(gTypes[1386])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::GenericSelectionExprOp::static_kind():
-      tp = &(gTypes[1385]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GenericSelectionExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericSelectionExprOp::result"),
-    nullptr,
-  },
-  {
-    "control",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->control());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericSelectionExprOp::control"),
-    nullptr,
-  },
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericSelectionExprOp::body"),
-    nullptr,
-  },
-  {
-    "control_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->control_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericSelectionExprOp::control_type"),
-    nullptr,
-  },
-  {
-    "is_expression_predicate",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_expression_predicate());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericSelectionExprOp::is_expression_predicate"),
-    nullptr,
-  },
-  {
-    "is_type_predicate",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_type_predicate());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericSelectionExprOp::is_type_predicate"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericSelectionExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericSelectionExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GenericSelectionExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1385]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.GenericSelectionExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::GenericSelectionExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GenericSelectionExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GenericSelectionExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GenericSelectionExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/GlobalRefOp.cpp b/bindings/Python/Generated/IR/HighLevel/GlobalRefOp.cpp
deleted file mode 100644
index 820ea3f75..000000000
--- a/bindings/Python/Generated/IR/HighLevel/GlobalRefOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::GlobalRefOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1320]) || tp >= &(gTypes[1321])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::GlobalRefOp::static_kind():
-      tp = &(gTypes[1320]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GlobalRefOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GlobalRefOp::result"),
-    nullptr,
-  },
-  {
-    "global_",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->global());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GlobalRefOp::global"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GlobalRefOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GlobalRefOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GlobalRefOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1320]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.GlobalRefOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::GlobalRefOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1316].tp_hash;
-  tp->tp_richcompare = gTypes[1316].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1316]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GlobalRefOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GlobalRefOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GlobalRefOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/GotoStmtOp.cpp b/bindings/Python/Generated/IR/HighLevel/GotoStmtOp.cpp
deleted file mode 100644
index 821a434d1..000000000
--- a/bindings/Python/Generated/IR/HighLevel/GotoStmtOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::GotoStmtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1386]) || tp >= &(gTypes[1387])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::GotoStmtOp::static_kind():
-      tp = &(gTypes[1386]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GotoStmtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "label",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->label());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::GotoStmtOp::label"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GotoStmtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GotoStmtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::GotoStmtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1386]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.GotoStmtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::GotoStmtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GotoStmtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GotoStmtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GotoStmtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/HalfType.cpp b/bindings/Python/Generated/IR/HighLevel/HalfType.cpp
deleted file mode 100644
index 648204e0f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/HalfType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::HalfType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1513]) || tp >= &(gTypes[1514])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::HalfType::static_kind():
-      tp = &(gTypes[1513]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "HalfType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::HalfType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::HalfType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1513]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.HalfType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::HalfType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'HalfType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'HalfType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'HalfType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/IfOp.cpp b/bindings/Python/Generated/IR/HighLevel/IfOp.cpp
deleted file mode 100644
index 04f652423..000000000
--- a/bindings/Python/Generated/IR/HighLevel/IfOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::IfOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1387]) || tp >= &(gTypes[1388])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::IfOp::static_kind():
-      tp = &(gTypes[1387]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IfOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "condition_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->condition_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::IfOp::condition_region"),
-    nullptr,
-  },
-  {
-    "then_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->then_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::IfOp::then_region"),
-    nullptr,
-  },
-  {
-    "else_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->else_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::IfOp::else_region"),
-    nullptr,
-  },
-  {
-    "has_else",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->has_else());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::IfOp::has_else"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IfOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IfOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IfOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1387]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.IfOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::IfOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IfOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IfOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IfOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ImagOp.cpp b/bindings/Python/Generated/IR/HighLevel/ImagOp.cpp
deleted file mode 100644
index daf22c5b1..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ImagOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ImagOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1388]) || tp >= &(gTypes[1389])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ImagOp::static_kind():
-      tp = &(gTypes[1388]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ImagOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImagOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImagOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImagOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImagOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImagOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1388]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ImagOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ImagOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ImagOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ImagOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ImagOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ImplicitCastOp.cpp b/bindings/Python/Generated/IR/HighLevel/ImplicitCastOp.cpp
deleted file mode 100644
index 3698c18a4..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ImplicitCastOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ImplicitCastOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1389]) || tp >= &(gTypes[1390])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ImplicitCastOp::static_kind():
-      tp = &(gTypes[1389]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ImplicitCastOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImplicitCastOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImplicitCastOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImplicitCastOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImplicitCastOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ImplicitCastOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1389]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ImplicitCastOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ImplicitCastOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ImplicitCastOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ImplicitCastOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ImplicitCastOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/IndirectCallOp.cpp b/bindings/Python/Generated/IR/HighLevel/IndirectCallOp.cpp
deleted file mode 100644
index 7f5ad5141..000000000
--- a/bindings/Python/Generated/IR/HighLevel/IndirectCallOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::IndirectCallOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1390]) || tp >= &(gTypes[1391])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::IndirectCallOp::static_kind():
-      tp = &(gTypes[1390]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IndirectCallOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "callee",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->callee());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectCallOp::callee"),
-    nullptr,
-  },
-  {
-    "arg_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arg_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectCallOp::arg_operands"),
-    nullptr,
-  },
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectCallOp::results"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectCallOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectCallOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectCallOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1390]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.IndirectCallOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::IndirectCallOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IndirectCallOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IndirectCallOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IndirectCallOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/IndirectGotoStmtOp.cpp b/bindings/Python/Generated/IR/HighLevel/IndirectGotoStmtOp.cpp
deleted file mode 100644
index 41509d836..000000000
--- a/bindings/Python/Generated/IR/HighLevel/IndirectGotoStmtOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::IndirectGotoStmtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1391]) || tp >= &(gTypes[1392])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::IndirectGotoStmtOp::static_kind():
-      tp = &(gTypes[1391]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IndirectGotoStmtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "target",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->target());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectGotoStmtOp::target"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectGotoStmtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectGotoStmtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IndirectGotoStmtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1391]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.IndirectGotoStmtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::IndirectGotoStmtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IndirectGotoStmtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IndirectGotoStmtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IndirectGotoStmtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/InitListExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/InitListExprOp.cpp
deleted file mode 100644
index 704d2232f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/InitListExprOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::InitListExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1392]) || tp >= &(gTypes[1393])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::InitListExprOp::static_kind():
-      tp = &(gTypes[1392]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InitListExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "elements",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::elements);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::InitListExprOp::elements"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::InitListExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::InitListExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::InitListExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1392]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.InitListExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::InitListExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InitListExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InitListExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InitListExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/InitializedConstantOp.cpp b/bindings/Python/Generated/IR/HighLevel/InitializedConstantOp.cpp
deleted file mode 100644
index cc2ae8a1e..000000000
--- a/bindings/Python/Generated/IR/HighLevel/InitializedConstantOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::InitializedConstantOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1393]) || tp >= &(gTypes[1394])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::InitializedConstantOp::static_kind():
-      tp = &(gTypes[1393]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InitializedConstantOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::InitializedConstantOp::result"),
-    nullptr,
-  },
-  {
-    "initializer",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->initializer());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::InitializedConstantOp::initializer"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::InitializedConstantOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::InitializedConstantOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::InitializedConstantOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1393]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.InitializedConstantOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::InitializedConstantOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InitializedConstantOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InitializedConstantOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InitializedConstantOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/Int128Type.cpp b/bindings/Python/Generated/IR/HighLevel/Int128Type.cpp
deleted file mode 100644
index 055937431..000000000
--- a/bindings/Python/Generated/IR/HighLevel/Int128Type.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::Int128Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1512]) || tp >= &(gTypes[1513])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::Int128Type::static_kind():
-      tp = &(gTypes[1512]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Int128Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::Int128Type::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::Int128Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1512]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.Int128Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::Int128Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Int128Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Int128Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Int128Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/IntType.cpp b/bindings/Python/Generated/IR/HighLevel/IntType.cpp
deleted file mode 100644
index 29622d7da..000000000
--- a/bindings/Python/Generated/IR/HighLevel/IntType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::IntType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1509]) || tp >= &(gTypes[1510])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::IntType::static_kind():
-      tp = &(gTypes[1509]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IntType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IntType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::IntType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1509]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.IntType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::IntType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IntType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IntType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IntType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LNotOp.cpp b/bindings/Python/Generated/IR/HighLevel/LNotOp.cpp
deleted file mode 100644
index 69dac85e9..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LNotOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LNotOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1394]) || tp >= &(gTypes[1395])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LNotOp::static_kind():
-      tp = &(gTypes[1394]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LNotOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::LNotOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::LNotOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LNotOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LNotOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LNotOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1394]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LNotOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LNotOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LNotOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LNotOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LNotOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LValueType.cpp b/bindings/Python/Generated/IR/HighLevel/LValueType.cpp
deleted file mode 100644
index 7f03b1563..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LValueType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LValueType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1503]) || tp >= &(gTypes[1504])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LValueType::static_kind():
-      tp = &(gTypes[1503]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LValueType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LValueType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LValueType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1503]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LValueType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LValueType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LValueType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LValueType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LValueType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LabelDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/LabelDeclOp.cpp
deleted file mode 100644
index 1659a0e51..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LabelDeclOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LabelDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1395]) || tp >= &(gTypes[1396])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LabelDeclOp::static_kind():
-      tp = &(gTypes[1395]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LabelDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelDeclOp::result"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelDeclOp::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1395]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LabelDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LabelDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LabelDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LabelDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LabelDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LabelStmtOp.cpp b/bindings/Python/Generated/IR/HighLevel/LabelStmtOp.cpp
deleted file mode 100644
index 10059c1ce..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LabelStmtOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LabelStmtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1396]) || tp >= &(gTypes[1397])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LabelStmtOp::static_kind():
-      tp = &(gTypes[1396]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LabelStmtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "label",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->label());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelStmtOp::label"),
-    nullptr,
-  },
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelStmtOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelStmtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelStmtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelStmtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1396]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LabelStmtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LabelStmtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LabelStmtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LabelStmtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LabelStmtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LabelType.cpp b/bindings/Python/Generated/IR/HighLevel/LabelType.cpp
deleted file mode 100644
index 47308e3d8..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LabelType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LabelType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1501]) || tp >= &(gTypes[1502])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LabelType::static_kind():
-      tp = &(gTypes[1501]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LabelType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LabelType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1501]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LabelType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LabelType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LabelType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LabelType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LabelType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LeafAttr.cpp b/bindings/Python/Generated/IR/HighLevel/LeafAttr.cpp
deleted file mode 100644
index f4f6187e4..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LeafAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LeafAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[958]) || tp >= &(gTypes[959])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LeafAttr::static_kind():
-      tp = &(gTypes[958]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LeafAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LeafAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LeafAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[958]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LeafAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LeafAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LeafAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LeafAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LeafAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LoaderUninitializedAttr.cpp b/bindings/Python/Generated/IR/HighLevel/LoaderUninitializedAttr.cpp
deleted file mode 100644
index a0065dada..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LoaderUninitializedAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LoaderUninitializedAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[950]) || tp >= &(gTypes[951])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LoaderUninitializedAttr::static_kind():
-      tp = &(gTypes[950]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoaderUninitializedAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LoaderUninitializedAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LoaderUninitializedAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[950]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LoaderUninitializedAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LoaderUninitializedAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoaderUninitializedAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoaderUninitializedAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoaderUninitializedAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LongDoubleType.cpp b/bindings/Python/Generated/IR/HighLevel/LongDoubleType.cpp
deleted file mode 100644
index 532f0ff69..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LongDoubleType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LongDoubleType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1517]) || tp >= &(gTypes[1518])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LongDoubleType::static_kind():
-      tp = &(gTypes[1517]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LongDoubleType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LongDoubleType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LongDoubleType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1517]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LongDoubleType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LongDoubleType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LongDoubleType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LongDoubleType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LongDoubleType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LongLongType.cpp b/bindings/Python/Generated/IR/HighLevel/LongLongType.cpp
deleted file mode 100644
index c01724c17..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LongLongType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LongLongType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1511]) || tp >= &(gTypes[1512])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LongLongType::static_kind():
-      tp = &(gTypes[1511]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LongLongType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LongLongType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LongLongType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1511]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LongLongType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LongLongType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LongLongType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LongLongType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LongLongType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/LongType.cpp b/bindings/Python/Generated/IR/HighLevel/LongType.cpp
deleted file mode 100644
index edca0321b..000000000
--- a/bindings/Python/Generated/IR/HighLevel/LongType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::LongType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1510]) || tp >= &(gTypes[1511])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::LongType::static_kind():
-      tp = &(gTypes[1510]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LongType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LongType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::LongType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1510]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.LongType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::LongType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LongType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LongType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LongType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/MaxFieldAlignmentAttr.cpp b/bindings/Python/Generated/IR/HighLevel/MaxFieldAlignmentAttr.cpp
deleted file mode 100644
index 499013554..000000000
--- a/bindings/Python/Generated/IR/HighLevel/MaxFieldAlignmentAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::MaxFieldAlignmentAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[977]) || tp >= &(gTypes[978])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::MaxFieldAlignmentAttr::static_kind():
-      tp = &(gTypes[977]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MaxFieldAlignmentAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MaxFieldAlignmentAttr::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MaxFieldAlignmentAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MaxFieldAlignmentAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[977]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.MaxFieldAlignmentAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::MaxFieldAlignmentAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MaxFieldAlignmentAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MaxFieldAlignmentAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MaxFieldAlignmentAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/MayAliasAttr.cpp b/bindings/Python/Generated/IR/HighLevel/MayAliasAttr.cpp
deleted file mode 100644
index 7ddae2a56..000000000
--- a/bindings/Python/Generated/IR/HighLevel/MayAliasAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::MayAliasAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[962]) || tp >= &(gTypes[963])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::MayAliasAttr::static_kind():
-      tp = &(gTypes[962]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MayAliasAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MayAliasAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MayAliasAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[962]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.MayAliasAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::MayAliasAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MayAliasAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MayAliasAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MayAliasAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/MinusOp.cpp b/bindings/Python/Generated/IR/HighLevel/MinusOp.cpp
deleted file mode 100644
index 8a69a0cef..000000000
--- a/bindings/Python/Generated/IR/HighLevel/MinusOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::MinusOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1397]) || tp >= &(gTypes[1398])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::MinusOp::static_kind():
-      tp = &(gTypes[1397]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MinusOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MinusOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MinusOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MinusOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MinusOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MinusOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1397]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.MinusOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::MinusOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MinusOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MinusOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MinusOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ModeAttr.cpp b/bindings/Python/Generated/IR/HighLevel/ModeAttr.cpp
deleted file mode 100644
index c02e10e7f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ModeAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ModeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[972]) || tp >= &(gTypes[973])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ModeAttr::static_kind():
-      tp = &(gTypes[972]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ModeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ModeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ModeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[972]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ModeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ModeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ModeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ModeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ModeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/MulFAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/MulFAssignOp.cpp
deleted file mode 100644
index ff1b6b8c8..000000000
--- a/bindings/Python/Generated/IR/HighLevel/MulFAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::MulFAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1398]) || tp >= &(gTypes[1399])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::MulFAssignOp::static_kind():
-      tp = &(gTypes[1398]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MulFAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1398]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.MulFAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::MulFAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MulFAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MulFAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MulFAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/MulFOp.cpp b/bindings/Python/Generated/IR/HighLevel/MulFOp.cpp
deleted file mode 100644
index e8e8b9c12..000000000
--- a/bindings/Python/Generated/IR/HighLevel/MulFOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::MulFOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1399]) || tp >= &(gTypes[1400])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::MulFOp::static_kind():
-      tp = &(gTypes[1399]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MulFOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulFOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1399]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.MulFOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::MulFOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MulFOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MulFOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MulFOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/MulIAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/MulIAssignOp.cpp
deleted file mode 100644
index 8db8fbb13..000000000
--- a/bindings/Python/Generated/IR/HighLevel/MulIAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::MulIAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1400]) || tp >= &(gTypes[1401])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::MulIAssignOp::static_kind():
-      tp = &(gTypes[1400]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MulIAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1400]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.MulIAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::MulIAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MulIAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MulIAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MulIAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/MulIOp.cpp b/bindings/Python/Generated/IR/HighLevel/MulIOp.cpp
deleted file mode 100644
index 2a8bd5058..000000000
--- a/bindings/Python/Generated/IR/HighLevel/MulIOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::MulIOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1401]) || tp >= &(gTypes[1402])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::MulIOp::static_kind():
-      tp = &(gTypes[1401]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MulIOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::MulIOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1401]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.MulIOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::MulIOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MulIOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MulIOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MulIOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/NoCfCheckAttr.cpp b/bindings/Python/Generated/IR/HighLevel/NoCfCheckAttr.cpp
deleted file mode 100644
index 0de1a81f3..000000000
--- a/bindings/Python/Generated/IR/HighLevel/NoCfCheckAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::NoCfCheckAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[966]) || tp >= &(gTypes[967])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::NoCfCheckAttr::static_kind():
-      tp = &(gTypes[966]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NoCfCheckAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoCfCheckAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoCfCheckAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[966]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.NoCfCheckAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::NoCfCheckAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NoCfCheckAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NoCfCheckAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NoCfCheckAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/NoInlineAttr.cpp b/bindings/Python/Generated/IR/HighLevel/NoInlineAttr.cpp
deleted file mode 100644
index 056a3b1cd..000000000
--- a/bindings/Python/Generated/IR/HighLevel/NoInlineAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::NoInlineAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[948]) || tp >= &(gTypes[949])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::NoInlineAttr::static_kind():
-      tp = &(gTypes[948]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NoInlineAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoInlineAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoInlineAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[948]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.NoInlineAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::NoInlineAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NoInlineAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NoInlineAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NoInlineAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/NoInstrumentFunctionAttr.cpp b/bindings/Python/Generated/IR/HighLevel/NoInstrumentFunctionAttr.cpp
deleted file mode 100644
index cb8a08f54..000000000
--- a/bindings/Python/Generated/IR/HighLevel/NoInstrumentFunctionAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::NoInstrumentFunctionAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[951]) || tp >= &(gTypes[952])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::NoInstrumentFunctionAttr::static_kind():
-      tp = &(gTypes[951]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NoInstrumentFunctionAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoInstrumentFunctionAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoInstrumentFunctionAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[951]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.NoInstrumentFunctionAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::NoInstrumentFunctionAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NoInstrumentFunctionAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NoInstrumentFunctionAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NoInstrumentFunctionAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/NoProfileInstrumentFunctionAttr.cpp b/bindings/Python/Generated/IR/HighLevel/NoProfileInstrumentFunctionAttr.cpp
deleted file mode 100644
index 330eafffb..000000000
--- a/bindings/Python/Generated/IR/HighLevel/NoProfileInstrumentFunctionAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::NoProfileInstrumentFunctionAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[970]) || tp >= &(gTypes[971])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::NoProfileInstrumentFunctionAttr::static_kind():
-      tp = &(gTypes[970]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NoProfileInstrumentFunctionAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoProfileInstrumentFunctionAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoProfileInstrumentFunctionAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[970]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.NoProfileInstrumentFunctionAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::NoProfileInstrumentFunctionAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NoProfileInstrumentFunctionAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NoProfileInstrumentFunctionAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NoProfileInstrumentFunctionAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/NoThrowAttr.cpp b/bindings/Python/Generated/IR/HighLevel/NoThrowAttr.cpp
deleted file mode 100644
index d5f83f29d..000000000
--- a/bindings/Python/Generated/IR/HighLevel/NoThrowAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::NoThrowAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[956]) || tp >= &(gTypes[957])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::NoThrowAttr::static_kind():
-      tp = &(gTypes[956]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NoThrowAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoThrowAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NoThrowAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[956]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.NoThrowAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::NoThrowAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NoThrowAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NoThrowAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NoThrowAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/NonNullAttr.cpp b/bindings/Python/Generated/IR/HighLevel/NonNullAttr.cpp
deleted file mode 100644
index 5351d400c..000000000
--- a/bindings/Python/Generated/IR/HighLevel/NonNullAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::NonNullAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[957]) || tp >= &(gTypes[958])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::NonNullAttr::static_kind():
-      tp = &(gTypes[957]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NonNullAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NonNullAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NonNullAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[957]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.NonNullAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::NonNullAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NonNullAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NonNullAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NonNullAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/NotOp.cpp b/bindings/Python/Generated/IR/HighLevel/NotOp.cpp
deleted file mode 100644
index 48cf482f7..000000000
--- a/bindings/Python/Generated/IR/HighLevel/NotOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::NotOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1402]) || tp >= &(gTypes[1403])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::NotOp::static_kind():
-      tp = &(gTypes[1402]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NotOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::NotOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::NotOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NotOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NotOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NotOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1402]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.NotOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::NotOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NotOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NotOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NotOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/NullStmtOp.cpp b/bindings/Python/Generated/IR/HighLevel/NullStmtOp.cpp
deleted file mode 100644
index d9a576bfa..000000000
--- a/bindings/Python/Generated/IR/HighLevel/NullStmtOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::NullStmtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1403]) || tp >= &(gTypes[1404])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::NullStmtOp::static_kind():
-      tp = &(gTypes[1403]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NullStmtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NullStmtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NullStmtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::NullStmtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1403]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.NullStmtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::NullStmtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NullStmtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NullStmtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NullStmtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/OffsetOfExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/OffsetOfExprOp.cpp
deleted file mode 100644
index edcdbc99c..000000000
--- a/bindings/Python/Generated/IR/HighLevel/OffsetOfExprOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::OffsetOfExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1404]) || tp >= &(gTypes[1405])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::OffsetOfExprOp::static_kind():
-      tp = &(gTypes[1404]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "OffsetOfExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::OffsetOfExprOp::result"),
-    nullptr,
-  },
-  {
-    "array_index_exprs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::array_index_exprs);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::OffsetOfExprOp::array_index_exprs"),
-    nullptr,
-  },
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::OffsetOfExprOp::source"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::OffsetOfExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::OffsetOfExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::OffsetOfExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1404]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.OffsetOfExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::OffsetOfExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'OffsetOfExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'OffsetOfExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'OffsetOfExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/OffsetOfNodeAttr.cpp b/bindings/Python/Generated/IR/HighLevel/OffsetOfNodeAttr.cpp
deleted file mode 100644
index 4f414bcfd..000000000
--- a/bindings/Python/Generated/IR/HighLevel/OffsetOfNodeAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::OffsetOfNodeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[983]) || tp >= &(gTypes[984])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::OffsetOfNodeAttr::static_kind():
-      tp = &(gTypes[983]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "OffsetOfNodeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::OffsetOfNodeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::OffsetOfNodeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[983]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.OffsetOfNodeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::OffsetOfNodeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'OffsetOfNodeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'OffsetOfNodeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'OffsetOfNodeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/OpaqueValueExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/OpaqueValueExprOp.cpp
deleted file mode 100644
index d34c4f049..000000000
--- a/bindings/Python/Generated/IR/HighLevel/OpaqueValueExprOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::OpaqueValueExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1405]) || tp >= &(gTypes[1406])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::OpaqueValueExprOp::static_kind():
-      tp = &(gTypes[1405]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "OpaqueValueExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::argument);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::OpaqueValueExprOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::OpaqueValueExprOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::OpaqueValueExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::OpaqueValueExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::OpaqueValueExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1405]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.OpaqueValueExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::OpaqueValueExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'OpaqueValueExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'OpaqueValueExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'OpaqueValueExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/Operation.cpp b/bindings/Python/Generated/IR/HighLevel/Operation.cpp
deleted file mode 100644
index ff06f69a7..000000000
--- a/bindings/Python/Generated/IR/HighLevel/Operation.cpp
+++ /dev/null
@@ -1,733 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::Operation;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1315]) || tp >= &(gTypes[1447])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DeclRefOp::static_kind():
-      tp = &(gTypes[1317]);
-      break;
-
-    case mx::ir::hl::EnumRefOp::static_kind():
-      tp = &(gTypes[1318]);
-      break;
-
-    case mx::ir::hl::FuncRefOp::static_kind():
-      tp = &(gTypes[1319]);
-      break;
-
-    case mx::ir::hl::GlobalRefOp::static_kind():
-      tp = &(gTypes[1320]);
-      break;
-
-    case mx::ir::hl::AccessSpecifierOp::static_kind():
-      tp = &(gTypes[1321]);
-      break;
-
-    case mx::ir::hl::AddFAssignOp::static_kind():
-      tp = &(gTypes[1322]);
-      break;
-
-    case mx::ir::hl::AddFOp::static_kind():
-      tp = &(gTypes[1323]);
-      break;
-
-    case mx::ir::hl::AddIAssignOp::static_kind():
-      tp = &(gTypes[1324]);
-      break;
-
-    case mx::ir::hl::AddIOp::static_kind():
-      tp = &(gTypes[1325]);
-      break;
-
-    case mx::ir::hl::AddrLabelExprOp::static_kind():
-      tp = &(gTypes[1326]);
-      break;
-
-    case mx::ir::hl::AddressOfOp::static_kind():
-      tp = &(gTypes[1327]);
-      break;
-
-    case mx::ir::hl::AlignOfExprOp::static_kind():
-      tp = &(gTypes[1328]);
-      break;
-
-    case mx::ir::hl::AlignOfTypeOp::static_kind():
-      tp = &(gTypes[1329]);
-      break;
-
-    case mx::ir::hl::AsmOp::static_kind():
-      tp = &(gTypes[1330]);
-      break;
-
-    case mx::ir::hl::AssignOp::static_kind():
-      tp = &(gTypes[1331]);
-      break;
-
-    case mx::ir::hl::AttributedStmtOp::static_kind():
-      tp = &(gTypes[1332]);
-      break;
-
-    case mx::ir::hl::BinAShrAssignOp::static_kind():
-      tp = &(gTypes[1333]);
-      break;
-
-    case mx::ir::hl::BinAShrOp::static_kind():
-      tp = &(gTypes[1334]);
-      break;
-
-    case mx::ir::hl::BinAndAssignOp::static_kind():
-      tp = &(gTypes[1335]);
-      break;
-
-    case mx::ir::hl::BinAndOp::static_kind():
-      tp = &(gTypes[1336]);
-      break;
-
-    case mx::ir::hl::BinCommaOp::static_kind():
-      tp = &(gTypes[1337]);
-      break;
-
-    case mx::ir::hl::BinLAndOp::static_kind():
-      tp = &(gTypes[1338]);
-      break;
-
-    case mx::ir::hl::BinLOrOp::static_kind():
-      tp = &(gTypes[1339]);
-      break;
-
-    case mx::ir::hl::BinLShrAssignOp::static_kind():
-      tp = &(gTypes[1340]);
-      break;
-
-    case mx::ir::hl::BinLShrOp::static_kind():
-      tp = &(gTypes[1341]);
-      break;
-
-    case mx::ir::hl::BinOrAssignOp::static_kind():
-      tp = &(gTypes[1342]);
-      break;
-
-    case mx::ir::hl::BinOrOp::static_kind():
-      tp = &(gTypes[1343]);
-      break;
-
-    case mx::ir::hl::BinShlAssignOp::static_kind():
-      tp = &(gTypes[1344]);
-      break;
-
-    case mx::ir::hl::BinShlOp::static_kind():
-      tp = &(gTypes[1345]);
-      break;
-
-    case mx::ir::hl::BinXorAssignOp::static_kind():
-      tp = &(gTypes[1346]);
-      break;
-
-    case mx::ir::hl::BinXorOp::static_kind():
-      tp = &(gTypes[1347]);
-      break;
-
-    case mx::ir::hl::BinaryCondOp::static_kind():
-      tp = &(gTypes[1348]);
-      break;
-
-    case mx::ir::hl::BreakOp::static_kind():
-      tp = &(gTypes[1349]);
-      break;
-
-    case mx::ir::hl::BuiltinBitCastOp::static_kind():
-      tp = &(gTypes[1350]);
-      break;
-
-    case mx::ir::hl::BuiltinTypesCompatiblePOp::static_kind():
-      tp = &(gTypes[1351]);
-      break;
-
-    case mx::ir::hl::CStyleCastOp::static_kind():
-      tp = &(gTypes[1352]);
-      break;
-
-    case mx::ir::hl::CallOp::static_kind():
-      tp = &(gTypes[1353]);
-      break;
-
-    case mx::ir::hl::CaseOp::static_kind():
-      tp = &(gTypes[1354]);
-      break;
-
-    case mx::ir::hl::ChooseExprOp::static_kind():
-      tp = &(gTypes[1355]);
-      break;
-
-    case mx::ir::hl::ClassDeclOp::static_kind():
-      tp = &(gTypes[1356]);
-      break;
-
-    case mx::ir::hl::CmpOp::static_kind():
-      tp = &(gTypes[1357]);
-      break;
-
-    case mx::ir::hl::CompoundLiteralOp::static_kind():
-      tp = &(gTypes[1358]);
-      break;
-
-    case mx::ir::hl::CondOp::static_kind():
-      tp = &(gTypes[1359]);
-      break;
-
-    case mx::ir::hl::CondYieldOp::static_kind():
-      tp = &(gTypes[1360]);
-      break;
-
-    case mx::ir::hl::ConstantOp::static_kind():
-      tp = &(gTypes[1361]);
-      break;
-
-    case mx::ir::hl::ContinueOp::static_kind():
-      tp = &(gTypes[1362]);
-      break;
-
-    case mx::ir::hl::CxxBaseSpecifierOp::static_kind():
-      tp = &(gTypes[1363]);
-      break;
-
-    case mx::ir::hl::CxxStructDeclOp::static_kind():
-      tp = &(gTypes[1364]);
-      break;
-
-    case mx::ir::hl::DefaultOp::static_kind():
-      tp = &(gTypes[1365]);
-      break;
-
-    case mx::ir::hl::DerefOp::static_kind():
-      tp = &(gTypes[1366]);
-      break;
-
-    case mx::ir::hl::DivFAssignOp::static_kind():
-      tp = &(gTypes[1367]);
-      break;
-
-    case mx::ir::hl::DivFOp::static_kind():
-      tp = &(gTypes[1368]);
-      break;
-
-    case mx::ir::hl::DivSAssignOp::static_kind():
-      tp = &(gTypes[1369]);
-      break;
-
-    case mx::ir::hl::DivSOp::static_kind():
-      tp = &(gTypes[1370]);
-      break;
-
-    case mx::ir::hl::DivUAssignOp::static_kind():
-      tp = &(gTypes[1371]);
-      break;
-
-    case mx::ir::hl::DivUOp::static_kind():
-      tp = &(gTypes[1372]);
-      break;
-
-    case mx::ir::hl::DoOp::static_kind():
-      tp = &(gTypes[1373]);
-      break;
-
-    case mx::ir::hl::EmptyDeclOp::static_kind():
-      tp = &(gTypes[1374]);
-      break;
-
-    case mx::ir::hl::EnumConstantOp::static_kind():
-      tp = &(gTypes[1375]);
-      break;
-
-    case mx::ir::hl::EnumDeclOp::static_kind():
-      tp = &(gTypes[1376]);
-      break;
-
-    case mx::ir::hl::ExprOp::static_kind():
-      tp = &(gTypes[1377]);
-      break;
-
-    case mx::ir::hl::ExtensionOp::static_kind():
-      tp = &(gTypes[1378]);
-      break;
-
-    case mx::ir::hl::FCmpOp::static_kind():
-      tp = &(gTypes[1379]);
-      break;
-
-    case mx::ir::hl::FieldDeclOp::static_kind():
-      tp = &(gTypes[1380]);
-      break;
-
-    case mx::ir::hl::FileScopeAsmOp::static_kind():
-      tp = &(gTypes[1381]);
-      break;
-
-    case mx::ir::hl::ForOp::static_kind():
-      tp = &(gTypes[1382]);
-      break;
-
-    case mx::ir::hl::FuncOp::static_kind():
-      tp = &(gTypes[1383]);
-      break;
-
-    case mx::ir::hl::GenericAssocExprOp::static_kind():
-      tp = &(gTypes[1384]);
-      break;
-
-    case mx::ir::hl::GenericSelectionExprOp::static_kind():
-      tp = &(gTypes[1385]);
-      break;
-
-    case mx::ir::hl::GotoStmtOp::static_kind():
-      tp = &(gTypes[1386]);
-      break;
-
-    case mx::ir::hl::IfOp::static_kind():
-      tp = &(gTypes[1387]);
-      break;
-
-    case mx::ir::hl::ImagOp::static_kind():
-      tp = &(gTypes[1388]);
-      break;
-
-    case mx::ir::hl::ImplicitCastOp::static_kind():
-      tp = &(gTypes[1389]);
-      break;
-
-    case mx::ir::hl::IndirectCallOp::static_kind():
-      tp = &(gTypes[1390]);
-      break;
-
-    case mx::ir::hl::IndirectGotoStmtOp::static_kind():
-      tp = &(gTypes[1391]);
-      break;
-
-    case mx::ir::hl::InitListExprOp::static_kind():
-      tp = &(gTypes[1392]);
-      break;
-
-    case mx::ir::hl::InitializedConstantOp::static_kind():
-      tp = &(gTypes[1393]);
-      break;
-
-    case mx::ir::hl::LNotOp::static_kind():
-      tp = &(gTypes[1394]);
-      break;
-
-    case mx::ir::hl::LabelDeclOp::static_kind():
-      tp = &(gTypes[1395]);
-      break;
-
-    case mx::ir::hl::LabelStmtOp::static_kind():
-      tp = &(gTypes[1396]);
-      break;
-
-    case mx::ir::hl::MinusOp::static_kind():
-      tp = &(gTypes[1397]);
-      break;
-
-    case mx::ir::hl::MulFAssignOp::static_kind():
-      tp = &(gTypes[1398]);
-      break;
-
-    case mx::ir::hl::MulFOp::static_kind():
-      tp = &(gTypes[1399]);
-      break;
-
-    case mx::ir::hl::MulIAssignOp::static_kind():
-      tp = &(gTypes[1400]);
-      break;
-
-    case mx::ir::hl::MulIOp::static_kind():
-      tp = &(gTypes[1401]);
-      break;
-
-    case mx::ir::hl::NotOp::static_kind():
-      tp = &(gTypes[1402]);
-      break;
-
-    case mx::ir::hl::NullStmtOp::static_kind():
-      tp = &(gTypes[1403]);
-      break;
-
-    case mx::ir::hl::OffsetOfExprOp::static_kind():
-      tp = &(gTypes[1404]);
-      break;
-
-    case mx::ir::hl::OpaqueValueExprOp::static_kind():
-      tp = &(gTypes[1405]);
-      break;
-
-    case mx::ir::hl::PlusOp::static_kind():
-      tp = &(gTypes[1406]);
-      break;
-
-    case mx::ir::hl::PostDecOp::static_kind():
-      tp = &(gTypes[1407]);
-      break;
-
-    case mx::ir::hl::PostIncOp::static_kind():
-      tp = &(gTypes[1408]);
-      break;
-
-    case mx::ir::hl::PreDecOp::static_kind():
-      tp = &(gTypes[1409]);
-      break;
-
-    case mx::ir::hl::PreIncOp::static_kind():
-      tp = &(gTypes[1410]);
-      break;
-
-    case mx::ir::hl::PredefinedExprOp::static_kind():
-      tp = &(gTypes[1411]);
-      break;
-
-    case mx::ir::hl::PreferredAlignOfExprOp::static_kind():
-      tp = &(gTypes[1412]);
-      break;
-
-    case mx::ir::hl::PreferredAlignOfTypeOp::static_kind():
-      tp = &(gTypes[1413]);
-      break;
-
-    case mx::ir::hl::RealOp::static_kind():
-      tp = &(gTypes[1414]);
-      break;
-
-    case mx::ir::hl::RecordMemberOp::static_kind():
-      tp = &(gTypes[1415]);
-      break;
-
-    case mx::ir::hl::RemFAssignOp::static_kind():
-      tp = &(gTypes[1416]);
-      break;
-
-    case mx::ir::hl::RemFOp::static_kind():
-      tp = &(gTypes[1417]);
-      break;
-
-    case mx::ir::hl::RemSAssignOp::static_kind():
-      tp = &(gTypes[1418]);
-      break;
-
-    case mx::ir::hl::RemSOp::static_kind():
-      tp = &(gTypes[1419]);
-      break;
-
-    case mx::ir::hl::RemUAssignOp::static_kind():
-      tp = &(gTypes[1420]);
-      break;
-
-    case mx::ir::hl::RemUOp::static_kind():
-      tp = &(gTypes[1421]);
-      break;
-
-    case mx::ir::hl::ReturnOp::static_kind():
-      tp = &(gTypes[1422]);
-      break;
-
-    case mx::ir::hl::SizeOfExprOp::static_kind():
-      tp = &(gTypes[1423]);
-      break;
-
-    case mx::ir::hl::SizeOfTypeOp::static_kind():
-      tp = &(gTypes[1424]);
-      break;
-
-    case mx::ir::hl::StaticAssertDeclOp::static_kind():
-      tp = &(gTypes[1425]);
-      break;
-
-    case mx::ir::hl::StmtExprOp::static_kind():
-      tp = &(gTypes[1426]);
-      break;
-
-    case mx::ir::hl::StructDeclOp::static_kind():
-      tp = &(gTypes[1427]);
-      break;
-
-    case mx::ir::hl::SubFAssignOp::static_kind():
-      tp = &(gTypes[1428]);
-      break;
-
-    case mx::ir::hl::SubFOp::static_kind():
-      tp = &(gTypes[1429]);
-      break;
-
-    case mx::ir::hl::SubIAssignOp::static_kind():
-      tp = &(gTypes[1430]);
-      break;
-
-    case mx::ir::hl::SubIOp::static_kind():
-      tp = &(gTypes[1431]);
-      break;
-
-    case mx::ir::hl::SubscriptOp::static_kind():
-      tp = &(gTypes[1432]);
-      break;
-
-    case mx::ir::hl::SwitchOp::static_kind():
-      tp = &(gTypes[1433]);
-      break;
-
-    case mx::ir::hl::ThisOp::static_kind():
-      tp = &(gTypes[1434]);
-      break;
-
-    case mx::ir::hl::TranslationUnitOp::static_kind():
-      tp = &(gTypes[1435]);
-      break;
-
-    case mx::ir::hl::TypeAliasOp::static_kind():
-      tp = &(gTypes[1436]);
-      break;
-
-    case mx::ir::hl::TypeDeclOp::static_kind():
-      tp = &(gTypes[1437]);
-      break;
-
-    case mx::ir::hl::TypeDefOp::static_kind():
-      tp = &(gTypes[1438]);
-      break;
-
-    case mx::ir::hl::TypeOfExprOp::static_kind():
-      tp = &(gTypes[1439]);
-      break;
-
-    case mx::ir::hl::TypeYieldOp::static_kind():
-      tp = &(gTypes[1440]);
-      break;
-
-    case mx::ir::hl::UnionDeclOp::static_kind():
-      tp = &(gTypes[1441]);
-      break;
-
-    case mx::ir::hl::UnreachableOp::static_kind():
-      tp = &(gTypes[1442]);
-      break;
-
-    case mx::ir::hl::VAArgExprOp::static_kind():
-      tp = &(gTypes[1443]);
-      break;
-
-    case mx::ir::hl::ValueYieldOp::static_kind():
-      tp = &(gTypes[1444]);
-      break;
-
-    case mx::ir::hl::VarDeclOp::static_kind():
-      tp = &(gTypes[1445]);
-      break;
-
-    case mx::ir::hl::WhileOp::static_kind():
-      tp = &(gTypes[1446]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operation", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::Operation::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1315]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.Operation";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::Operation");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[998].tp_hash;
-  tp->tp_richcompare = gTypes[998].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[998]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operation.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operation.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operation' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PackedAttr.cpp b/bindings/Python/Generated/IR/HighLevel/PackedAttr.cpp
deleted file mode 100644
index 3ac5b2dcb..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PackedAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PackedAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[952]) || tp >= &(gTypes[953])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PackedAttr::static_kind():
-      tp = &(gTypes[952]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PackedAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PackedAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PackedAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[952]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PackedAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PackedAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PackedAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PackedAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PackedAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ParenType.cpp b/bindings/Python/Generated/IR/HighLevel/ParenType.cpp
deleted file mode 100644
index 438cc372c..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ParenType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ParenType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1502]) || tp >= &(gTypes[1503])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ParenType::static_kind():
-      tp = &(gTypes[1502]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ParenType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ParenType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ParenType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1502]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ParenType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ParenType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ParenType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ParenType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ParenType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PlusOp.cpp b/bindings/Python/Generated/IR/HighLevel/PlusOp.cpp
deleted file mode 100644
index 4ea53c564..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PlusOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PlusOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1406]) || tp >= &(gTypes[1407])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PlusOp::static_kind():
-      tp = &(gTypes[1406]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PlusOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PlusOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PlusOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PlusOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PlusOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PlusOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1406]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PlusOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PlusOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PlusOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PlusOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PlusOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PointerType.cpp b/bindings/Python/Generated/IR/HighLevel/PointerType.cpp
deleted file mode 100644
index 7a1ba5a91..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PointerType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PointerType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1520]) || tp >= &(gTypes[1521])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PointerType::static_kind():
-      tp = &(gTypes[1520]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PointerType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PointerType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PointerType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1520]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PointerType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PointerType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PointerType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PointerType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PointerType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PostDecOp.cpp b/bindings/Python/Generated/IR/HighLevel/PostDecOp.cpp
deleted file mode 100644
index 199bb5ec0..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PostDecOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PostDecOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1407]) || tp >= &(gTypes[1408])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PostDecOp::static_kind():
-      tp = &(gTypes[1407]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PostDecOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostDecOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostDecOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostDecOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostDecOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostDecOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1407]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PostDecOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PostDecOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PostDecOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PostDecOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PostDecOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PostIncOp.cpp b/bindings/Python/Generated/IR/HighLevel/PostIncOp.cpp
deleted file mode 100644
index 47ff55803..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PostIncOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PostIncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1408]) || tp >= &(gTypes[1409])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PostIncOp::static_kind():
-      tp = &(gTypes[1408]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PostIncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostIncOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostIncOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostIncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostIncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PostIncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1408]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PostIncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PostIncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PostIncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PostIncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PostIncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PreDecOp.cpp b/bindings/Python/Generated/IR/HighLevel/PreDecOp.cpp
deleted file mode 100644
index 031158255..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PreDecOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PreDecOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1409]) || tp >= &(gTypes[1410])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PreDecOp::static_kind():
-      tp = &(gTypes[1409]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PreDecOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreDecOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreDecOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreDecOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreDecOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreDecOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1409]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PreDecOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PreDecOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PreDecOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PreDecOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PreDecOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PreIncOp.cpp b/bindings/Python/Generated/IR/HighLevel/PreIncOp.cpp
deleted file mode 100644
index ce1278f52..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PreIncOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PreIncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1410]) || tp >= &(gTypes[1411])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PreIncOp::static_kind():
-      tp = &(gTypes[1410]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PreIncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreIncOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreIncOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreIncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreIncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreIncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1410]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PreIncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PreIncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PreIncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PreIncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PreIncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PredefinedExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/PredefinedExprOp.cpp
deleted file mode 100644
index 035b11c08..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PredefinedExprOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PredefinedExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1411]) || tp >= &(gTypes[1412])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PredefinedExprOp::static_kind():
-      tp = &(gTypes[1411]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PredefinedExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PredefinedExprOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PredefinedExprOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PredefinedExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PredefinedExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PredefinedExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1411]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PredefinedExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PredefinedExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PredefinedExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PredefinedExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PredefinedExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PreferredAlignOfExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/PreferredAlignOfExprOp.cpp
deleted file mode 100644
index c4bb4d97c..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PreferredAlignOfExprOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PreferredAlignOfExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1412]) || tp >= &(gTypes[1413])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PreferredAlignOfExprOp::static_kind():
-      tp = &(gTypes[1412]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PreferredAlignOfExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfExprOp::result"),
-    nullptr,
-  },
-  {
-    "expression",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->expression());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfExprOp::expression"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1412]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PreferredAlignOfExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PreferredAlignOfExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PreferredAlignOfExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PreferredAlignOfExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PreferredAlignOfExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PreferredAlignOfTypeOp.cpp b/bindings/Python/Generated/IR/HighLevel/PreferredAlignOfTypeOp.cpp
deleted file mode 100644
index fbcdf56d0..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PreferredAlignOfTypeOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PreferredAlignOfTypeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1413]) || tp >= &(gTypes[1414])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PreferredAlignOfTypeOp::static_kind():
-      tp = &(gTypes[1413]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PreferredAlignOfTypeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfTypeOp::result"),
-    nullptr,
-  },
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfTypeOp::argument"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfTypeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfTypeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PreferredAlignOfTypeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1413]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PreferredAlignOfTypeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PreferredAlignOfTypeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PreferredAlignOfTypeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PreferredAlignOfTypeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PreferredAlignOfTypeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/PureAttr.cpp b/bindings/Python/Generated/IR/HighLevel/PureAttr.cpp
deleted file mode 100644
index a7b05074c..000000000
--- a/bindings/Python/Generated/IR/HighLevel/PureAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::PureAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[953]) || tp >= &(gTypes[954])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::PureAttr::static_kind():
-      tp = &(gTypes[953]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PureAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PureAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::PureAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[953]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.PureAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::PureAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PureAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PureAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PureAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RValueType.cpp b/bindings/Python/Generated/IR/HighLevel/RValueType.cpp
deleted file mode 100644
index 398ff0674..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RValueType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RValueType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1504]) || tp >= &(gTypes[1505])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RValueType::static_kind():
-      tp = &(gTypes[1504]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RValueType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RValueType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RValueType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1504]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RValueType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RValueType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RValueType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RValueType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RValueType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RealOp.cpp b/bindings/Python/Generated/IR/HighLevel/RealOp.cpp
deleted file mode 100644
index 1113ac9fe..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RealOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RealOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1414]) || tp >= &(gTypes[1415])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RealOp::static_kind():
-      tp = &(gTypes[1414]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RealOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RealOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RealOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RealOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RealOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RealOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1414]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RealOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RealOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RealOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RealOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RealOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RecordMemberOp.cpp b/bindings/Python/Generated/IR/HighLevel/RecordMemberOp.cpp
deleted file mode 100644
index 12fdfcc39..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RecordMemberOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RecordMemberOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1415]) || tp >= &(gTypes[1416])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RecordMemberOp::static_kind():
-      tp = &(gTypes[1415]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RecordMemberOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "record",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->record());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RecordMemberOp::record"),
-    nullptr,
-  },
-  {
-    "element",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->element());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RecordMemberOp::element"),
-    nullptr,
-  },
-  {
-    "field",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->field());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RecordMemberOp::field"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RecordMemberOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RecordMemberOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RecordMemberOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1415]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RecordMemberOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RecordMemberOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RecordMemberOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RecordMemberOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RecordMemberOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RecordType.cpp b/bindings/Python/Generated/IR/HighLevel/RecordType.cpp
deleted file mode 100644
index b8b9a5e6d..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RecordType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RecordType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1497]) || tp >= &(gTypes[1498])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RecordType::static_kind():
-      tp = &(gTypes[1497]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RecordType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RecordType::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RecordType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RecordType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1497]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RecordType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RecordType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RecordType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RecordType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RecordType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RefOp.cpp b/bindings/Python/Generated/IR/HighLevel/RefOp.cpp
deleted file mode 100644
index 6cff77340..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RefOp.cpp
+++ /dev/null
@@ -1,239 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RefOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1316]) || tp >= &(gTypes[1321])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::DeclRefOp::static_kind():
-      tp = &(gTypes[1317]);
-      break;
-
-    case mx::ir::hl::EnumRefOp::static_kind():
-      tp = &(gTypes[1318]);
-      break;
-
-    case mx::ir::hl::FuncRefOp::static_kind():
-      tp = &(gTypes[1319]);
-      break;
-
-    case mx::ir::hl::GlobalRefOp::static_kind():
-      tp = &(gTypes[1320]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RefOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "referenced_symbol",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->referenced_symbol());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RefOp::referenced_symbol"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RefOp::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1316]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RefOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RefOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RefOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RefOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RefOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ReferenceType.cpp b/bindings/Python/Generated/IR/HighLevel/ReferenceType.cpp
deleted file mode 100644
index 4c4ac9007..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ReferenceType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ReferenceType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1526]) || tp >= &(gTypes[1527])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ReferenceType::static_kind():
-      tp = &(gTypes[1526]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ReferenceType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ReferenceType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ReferenceType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1526]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ReferenceType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ReferenceType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ReferenceType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ReferenceType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ReferenceType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RemFAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/RemFAssignOp.cpp
deleted file mode 100644
index e015c10dd..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RemFAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RemFAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1416]) || tp >= &(gTypes[1417])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RemFAssignOp::static_kind():
-      tp = &(gTypes[1416]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RemFAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1416]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RemFAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RemFAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RemFAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RemFAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RemFAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RemFOp.cpp b/bindings/Python/Generated/IR/HighLevel/RemFOp.cpp
deleted file mode 100644
index be1236309..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RemFOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RemFOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1417]) || tp >= &(gTypes[1418])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RemFOp::static_kind():
-      tp = &(gTypes[1417]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RemFOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemFOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1417]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RemFOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RemFOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RemFOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RemFOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RemFOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RemSAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/RemSAssignOp.cpp
deleted file mode 100644
index a2dfee19b..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RemSAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RemSAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1418]) || tp >= &(gTypes[1419])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RemSAssignOp::static_kind():
-      tp = &(gTypes[1418]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RemSAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1418]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RemSAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RemSAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RemSAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RemSAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RemSAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RemSOp.cpp b/bindings/Python/Generated/IR/HighLevel/RemSOp.cpp
deleted file mode 100644
index 720ae0750..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RemSOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RemSOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1419]) || tp >= &(gTypes[1420])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RemSOp::static_kind():
-      tp = &(gTypes[1419]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RemSOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemSOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1419]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RemSOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RemSOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RemSOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RemSOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RemSOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RemUAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/RemUAssignOp.cpp
deleted file mode 100644
index fdd5c1463..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RemUAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RemUAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1420]) || tp >= &(gTypes[1421])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RemUAssignOp::static_kind():
-      tp = &(gTypes[1420]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RemUAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1420]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RemUAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RemUAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RemUAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RemUAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RemUAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RemUOp.cpp b/bindings/Python/Generated/IR/HighLevel/RemUOp.cpp
deleted file mode 100644
index 83fb407a5..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RemUOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RemUOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1421]) || tp >= &(gTypes[1422])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RemUOp::static_kind():
-      tp = &(gTypes[1421]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RemUOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RemUOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1421]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RemUOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RemUOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RemUOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RemUOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RemUOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/RestrictAttr.cpp b/bindings/Python/Generated/IR/HighLevel/RestrictAttr.cpp
deleted file mode 100644
index 49486147f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/RestrictAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::RestrictAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[955]) || tp >= &(gTypes[956])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RestrictAttr::static_kind():
-      tp = &(gTypes[955]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RestrictAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RestrictAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::RestrictAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[955]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.RestrictAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::RestrictAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RestrictAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RestrictAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RestrictAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ReturnOp.cpp b/bindings/Python/Generated/IR/HighLevel/ReturnOp.cpp
deleted file mode 100644
index 33d96d665..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ReturnOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ReturnOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1422]) || tp >= &(gTypes[1423])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ReturnOp::static_kind():
-      tp = &(gTypes[1422]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ReturnOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::result);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ReturnOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ReturnOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ReturnOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ReturnOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1422]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ReturnOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ReturnOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ReturnOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ReturnOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ReturnOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ReturnsTwiceAttr.cpp b/bindings/Python/Generated/IR/HighLevel/ReturnsTwiceAttr.cpp
deleted file mode 100644
index c12f26f42..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ReturnsTwiceAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ReturnsTwiceAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[961]) || tp >= &(gTypes[962])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ReturnsTwiceAttr::static_kind():
-      tp = &(gTypes[961]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ReturnsTwiceAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ReturnsTwiceAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ReturnsTwiceAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[961]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ReturnsTwiceAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ReturnsTwiceAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ReturnsTwiceAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ReturnsTwiceAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ReturnsTwiceAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/SectionAttr.cpp b/bindings/Python/Generated/IR/HighLevel/SectionAttr.cpp
deleted file mode 100644
index 4e8d4c9f6..000000000
--- a/bindings/Python/Generated/IR/HighLevel/SectionAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::SectionAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[941]) || tp >= &(gTypes[942])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::SectionAttr::static_kind():
-      tp = &(gTypes[941]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SectionAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SectionAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SectionAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[941]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.SectionAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::SectionAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SectionAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SectionAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SectionAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ShortType.cpp b/bindings/Python/Generated/IR/HighLevel/ShortType.cpp
deleted file mode 100644
index 416619656..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ShortType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ShortType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1508]) || tp >= &(gTypes[1509])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ShortType::static_kind():
-      tp = &(gTypes[1508]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ShortType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ShortType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ShortType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1508]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ShortType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ShortType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ShortType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ShortType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ShortType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/SizeOfExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/SizeOfExprOp.cpp
deleted file mode 100644
index 0e459c9b6..000000000
--- a/bindings/Python/Generated/IR/HighLevel/SizeOfExprOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::SizeOfExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1423]) || tp >= &(gTypes[1424])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::SizeOfExprOp::static_kind():
-      tp = &(gTypes[1423]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SizeOfExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfExprOp::result"),
-    nullptr,
-  },
-  {
-    "expression",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->expression());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfExprOp::expression"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfExprOp::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1423]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.SizeOfExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::SizeOfExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SizeOfExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SizeOfExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SizeOfExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/SizeOfTypeOp.cpp b/bindings/Python/Generated/IR/HighLevel/SizeOfTypeOp.cpp
deleted file mode 100644
index 0abd8b7ae..000000000
--- a/bindings/Python/Generated/IR/HighLevel/SizeOfTypeOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::SizeOfTypeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1424]) || tp >= &(gTypes[1425])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::SizeOfTypeOp::static_kind():
-      tp = &(gTypes[1424]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SizeOfTypeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfTypeOp::result"),
-    nullptr,
-  },
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfTypeOp::argument"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfTypeOp::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfTypeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfTypeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SizeOfTypeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1424]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.SizeOfTypeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::SizeOfTypeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SizeOfTypeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SizeOfTypeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SizeOfTypeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/StaticAssertDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/StaticAssertDeclOp.cpp
deleted file mode 100644
index a18b8b673..000000000
--- a/bindings/Python/Generated/IR/HighLevel/StaticAssertDeclOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::StaticAssertDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1425]) || tp >= &(gTypes[1426])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::StaticAssertDeclOp::static_kind():
-      tp = &(gTypes[1425]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StaticAssertDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "assertion",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->assertion());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StaticAssertDeclOp::assertion"),
-    nullptr,
-  },
-  {
-    "message",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->message());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StaticAssertDeclOp::message"),
-    nullptr,
-  },
-  {
-    "failed",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->failed());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StaticAssertDeclOp::failed"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::StaticAssertDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::StaticAssertDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::StaticAssertDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1425]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.StaticAssertDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::StaticAssertDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StaticAssertDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StaticAssertDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StaticAssertDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/StmtExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/StmtExprOp.cpp
deleted file mode 100644
index d351e9fd7..000000000
--- a/bindings/Python/Generated/IR/HighLevel/StmtExprOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::StmtExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1426]) || tp >= &(gTypes[1427])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::StmtExprOp::static_kind():
-      tp = &(gTypes[1426]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StmtExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StmtExprOp::result"),
-    nullptr,
-  },
-  {
-    "nested_statement",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->nested_statement());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StmtExprOp::nested_statement"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::StmtExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::StmtExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::StmtExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1426]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.StmtExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::StmtExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StmtExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StmtExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StmtExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/StructDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/StructDeclOp.cpp
deleted file mode 100644
index 1b2141a99..000000000
--- a/bindings/Python/Generated/IR/HighLevel/StructDeclOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::StructDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1427]) || tp >= &(gTypes[1428])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::StructDeclOp::static_kind():
-      tp = &(gTypes[1427]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StructDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "fields",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->fields());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StructDeclOp::fields"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StructDeclOp::name"),
-    nullptr,
-  },
-  {
-    "field_types",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::field_types);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StructDeclOp::field_types"),
-    nullptr,
-  },
-  {
-    "defined_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->defined_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StructDeclOp::defined_type"),
-    nullptr,
-  },
-  {
-    "is_complete_definition",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_complete_definition());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StructDeclOp::is_complete_definition"),
-    nullptr,
-  },
-  {
-    "fields_block",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->fields_block());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::StructDeclOp::fields_block"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::StructDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::StructDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::StructDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1427]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.StructDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::StructDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StructDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StructDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StructDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/SubFAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/SubFAssignOp.cpp
deleted file mode 100644
index f89369e8a..000000000
--- a/bindings/Python/Generated/IR/HighLevel/SubFAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::SubFAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1428]) || tp >= &(gTypes[1429])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::SubFAssignOp::static_kind():
-      tp = &(gTypes[1428]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SubFAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1428]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.SubFAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::SubFAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SubFAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SubFAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SubFAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/SubFOp.cpp b/bindings/Python/Generated/IR/HighLevel/SubFOp.cpp
deleted file mode 100644
index 4fb2072b9..000000000
--- a/bindings/Python/Generated/IR/HighLevel/SubFOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::SubFOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1429]) || tp >= &(gTypes[1430])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::SubFOp::static_kind():
-      tp = &(gTypes[1429]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SubFOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubFOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1429]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.SubFOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::SubFOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SubFOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SubFOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SubFOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/SubIAssignOp.cpp b/bindings/Python/Generated/IR/HighLevel/SubIAssignOp.cpp
deleted file mode 100644
index 04b5801b2..000000000
--- a/bindings/Python/Generated/IR/HighLevel/SubIAssignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::SubIAssignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1430]) || tp >= &(gTypes[1431])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::SubIAssignOp::static_kind():
-      tp = &(gTypes[1430]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SubIAssignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIAssignOp::source"),
-    nullptr,
-  },
-  {
-    "destination",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->destination());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIAssignOp::destination"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIAssignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIAssignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIAssignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIAssignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1430]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.SubIAssignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::SubIAssignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SubIAssignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SubIAssignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SubIAssignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/SubIOp.cpp b/bindings/Python/Generated/IR/HighLevel/SubIOp.cpp
deleted file mode 100644
index 74bcbc7b4..000000000
--- a/bindings/Python/Generated/IR/HighLevel/SubIOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::SubIOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1431]) || tp >= &(gTypes[1432])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::SubIOp::static_kind():
-      tp = &(gTypes[1431]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SubIOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubIOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1431]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.SubIOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::SubIOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SubIOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SubIOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SubIOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/SubscriptOp.cpp b/bindings/Python/Generated/IR/HighLevel/SubscriptOp.cpp
deleted file mode 100644
index 25bf57635..000000000
--- a/bindings/Python/Generated/IR/HighLevel/SubscriptOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::SubscriptOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1432]) || tp >= &(gTypes[1433])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::SubscriptOp::static_kind():
-      tp = &(gTypes[1432]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SubscriptOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "array",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->array());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubscriptOp::array"),
-    nullptr,
-  },
-  {
-    "index",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->index());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubscriptOp::index"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubscriptOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubscriptOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubscriptOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SubscriptOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1432]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.SubscriptOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::SubscriptOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SubscriptOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SubscriptOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SubscriptOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/SwitchOp.cpp b/bindings/Python/Generated/IR/HighLevel/SwitchOp.cpp
deleted file mode 100644
index 8d215307a..000000000
--- a/bindings/Python/Generated/IR/HighLevel/SwitchOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::SwitchOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1433]) || tp >= &(gTypes[1434])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::SwitchOp::static_kind():
-      tp = &(gTypes[1433]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SwitchOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "condition_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->condition_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SwitchOp::condition_region"),
-    nullptr,
-  },
-  {
-    "cases",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::cases);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::SwitchOp::cases"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SwitchOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SwitchOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::SwitchOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1433]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.SwitchOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::SwitchOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SwitchOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SwitchOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SwitchOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ThisOp.cpp b/bindings/Python/Generated/IR/HighLevel/ThisOp.cpp
deleted file mode 100644
index a4ef3cc09..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ThisOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ThisOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1434]) || tp >= &(gTypes[1435])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ThisOp::static_kind():
-      tp = &(gTypes[1434]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ThisOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ThisOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ThisOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ThisOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ThisOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1434]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ThisOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ThisOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ThisOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ThisOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ThisOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TranslationUnitOp.cpp b/bindings/Python/Generated/IR/HighLevel/TranslationUnitOp.cpp
deleted file mode 100644
index 75fc44495..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TranslationUnitOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TranslationUnitOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1435]) || tp >= &(gTypes[1436])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TranslationUnitOp::static_kind():
-      tp = &(gTypes[1435]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TranslationUnitOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TranslationUnitOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TranslationUnitOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TranslationUnitOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TranslationUnitOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1435]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TranslationUnitOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TranslationUnitOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TranslationUnitOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TranslationUnitOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TranslationUnitOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TransparentUnionAttr.cpp b/bindings/Python/Generated/IR/HighLevel/TransparentUnionAttr.cpp
deleted file mode 100644
index 7f432d5f5..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TransparentUnionAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TransparentUnionAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[960]) || tp >= &(gTypes[961])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TransparentUnionAttr::static_kind():
-      tp = &(gTypes[960]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TransparentUnionAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TransparentUnionAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TransparentUnionAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[960]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TransparentUnionAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TransparentUnionAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TransparentUnionAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TransparentUnionAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TransparentUnionAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/Type.cpp b/bindings/Python/Generated/IR/HighLevel/Type.cpp
deleted file mode 100644
index 992696480..000000000
--- a/bindings/Python/Generated/IR/HighLevel/Type.cpp
+++ /dev/null
@@ -1,349 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1496]) || tp >= &(gTypes[1531])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::RecordType::static_kind():
-      tp = &(gTypes[1497]);
-      break;
-
-    case mx::ir::hl::EnumType::static_kind():
-      tp = &(gTypes[1498]);
-      break;
-
-    case mx::ir::hl::TypedefType::static_kind():
-      tp = &(gTypes[1499]);
-      break;
-
-    case mx::ir::hl::ElaboratedType::static_kind():
-      tp = &(gTypes[1500]);
-      break;
-
-    case mx::ir::hl::LabelType::static_kind():
-      tp = &(gTypes[1501]);
-      break;
-
-    case mx::ir::hl::ParenType::static_kind():
-      tp = &(gTypes[1502]);
-      break;
-
-    case mx::ir::hl::LValueType::static_kind():
-      tp = &(gTypes[1503]);
-      break;
-
-    case mx::ir::hl::RValueType::static_kind():
-      tp = &(gTypes[1504]);
-      break;
-
-    case mx::ir::hl::VoidType::static_kind():
-      tp = &(gTypes[1505]);
-      break;
-
-    case mx::ir::hl::BoolType::static_kind():
-      tp = &(gTypes[1506]);
-      break;
-
-    case mx::ir::hl::CharType::static_kind():
-      tp = &(gTypes[1507]);
-      break;
-
-    case mx::ir::hl::ShortType::static_kind():
-      tp = &(gTypes[1508]);
-      break;
-
-    case mx::ir::hl::IntType::static_kind():
-      tp = &(gTypes[1509]);
-      break;
-
-    case mx::ir::hl::LongType::static_kind():
-      tp = &(gTypes[1510]);
-      break;
-
-    case mx::ir::hl::LongLongType::static_kind():
-      tp = &(gTypes[1511]);
-      break;
-
-    case mx::ir::hl::Int128Type::static_kind():
-      tp = &(gTypes[1512]);
-      break;
-
-    case mx::ir::hl::HalfType::static_kind():
-      tp = &(gTypes[1513]);
-      break;
-
-    case mx::ir::hl::BFloat16Type::static_kind():
-      tp = &(gTypes[1514]);
-      break;
-
-    case mx::ir::hl::FloatType::static_kind():
-      tp = &(gTypes[1515]);
-      break;
-
-    case mx::ir::hl::DoubleType::static_kind():
-      tp = &(gTypes[1516]);
-      break;
-
-    case mx::ir::hl::LongDoubleType::static_kind():
-      tp = &(gTypes[1517]);
-      break;
-
-    case mx::ir::hl::Float128Type::static_kind():
-      tp = &(gTypes[1518]);
-      break;
-
-    case mx::ir::hl::ComplexType::static_kind():
-      tp = &(gTypes[1519]);
-      break;
-
-    case mx::ir::hl::PointerType::static_kind():
-      tp = &(gTypes[1520]);
-      break;
-
-    case mx::ir::hl::ArrayType::static_kind():
-      tp = &(gTypes[1521]);
-      break;
-
-    case mx::ir::hl::VectorType::static_kind():
-      tp = &(gTypes[1522]);
-      break;
-
-    case mx::ir::hl::DecayedType::static_kind():
-      tp = &(gTypes[1523]);
-      break;
-
-    case mx::ir::hl::AttributedType::static_kind():
-      tp = &(gTypes[1524]);
-      break;
-
-    case mx::ir::hl::AdjustedType::static_kind():
-      tp = &(gTypes[1525]);
-      break;
-
-    case mx::ir::hl::ReferenceType::static_kind():
-      tp = &(gTypes[1526]);
-      break;
-
-    case mx::ir::hl::TypeOfExprType::static_kind():
-      tp = &(gTypes[1527]);
-      break;
-
-    case mx::ir::hl::TypeOfTypeType::static_kind():
-      tp = &(gTypes[1528]);
-      break;
-
-    case mx::ir::hl::AutoType::static_kind():
-      tp = &(gTypes[1529]);
-      break;
-
-    case mx::ir::hl::AtomicType::static_kind():
-      tp = &(gTypes[1530]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1496]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1461].tp_hash;
-  tp->tp_richcompare = gTypes[1461].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1461]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TypeAliasOp.cpp b/bindings/Python/Generated/IR/HighLevel/TypeAliasOp.cpp
deleted file mode 100644
index 9314ae9ce..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TypeAliasOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TypeAliasOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1436]) || tp >= &(gTypes[1437])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TypeAliasOp::static_kind():
-      tp = &(gTypes[1436]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypeAliasOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeAliasOp::name"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeAliasOp::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeAliasOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeAliasOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeAliasOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1436]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TypeAliasOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TypeAliasOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypeAliasOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypeAliasOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypeAliasOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TypeDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/TypeDeclOp.cpp
deleted file mode 100644
index f8f5ecbe1..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TypeDeclOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TypeDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1437]) || tp >= &(gTypes[1438])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TypeDeclOp::static_kind():
-      tp = &(gTypes[1437]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypeDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDeclOp::name"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDeclOp::type"),
-    nullptr,
-  },
-  {
-    "defined_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->defined_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDeclOp::defined_type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1437]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TypeDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TypeDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypeDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypeDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypeDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TypeDefOp.cpp b/bindings/Python/Generated/IR/HighLevel/TypeDefOp.cpp
deleted file mode 100644
index 49dad078f..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TypeDefOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TypeDefOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1438]) || tp >= &(gTypes[1439])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TypeDefOp::static_kind():
-      tp = &(gTypes[1438]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypeDefOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDefOp::name"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDefOp::type"),
-    nullptr,
-  },
-  {
-    "defined_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->defined_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDefOp::defined_type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDefOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDefOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeDefOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1438]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TypeDefOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TypeDefOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypeDefOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypeDefOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypeDefOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TypeOfExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/TypeOfExprOp.cpp
deleted file mode 100644
index 2b7e74093..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TypeOfExprOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TypeOfExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1439]) || tp >= &(gTypes[1440])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TypeOfExprOp::static_kind():
-      tp = &(gTypes[1439]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypeOfExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "expression",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->expression());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfExprOp::expression"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfExprOp::name"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfExprOp::type"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1439]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TypeOfExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TypeOfExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypeOfExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypeOfExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypeOfExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TypeOfExprType.cpp b/bindings/Python/Generated/IR/HighLevel/TypeOfExprType.cpp
deleted file mode 100644
index 69b815983..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TypeOfExprType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TypeOfExprType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1527]) || tp >= &(gTypes[1528])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TypeOfExprType::static_kind():
-      tp = &(gTypes[1527]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypeOfExprType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfExprType::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfExprType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfExprType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1527]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TypeOfExprType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TypeOfExprType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypeOfExprType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypeOfExprType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypeOfExprType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TypeOfTypeType.cpp b/bindings/Python/Generated/IR/HighLevel/TypeOfTypeType.cpp
deleted file mode 100644
index 9deca418b..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TypeOfTypeType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TypeOfTypeType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1528]) || tp >= &(gTypes[1529])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TypeOfTypeType::static_kind():
-      tp = &(gTypes[1528]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypeOfTypeType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfTypeType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeOfTypeType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1528]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TypeOfTypeType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TypeOfTypeType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypeOfTypeType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypeOfTypeType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypeOfTypeType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TypeYieldOp.cpp b/bindings/Python/Generated/IR/HighLevel/TypeYieldOp.cpp
deleted file mode 100644
index abef4f732..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TypeYieldOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TypeYieldOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1440]) || tp >= &(gTypes[1441])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TypeYieldOp::static_kind():
-      tp = &(gTypes[1440]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypeYieldOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeYieldOp::result"),
-    nullptr,
-  },
-  {
-    "yielded",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->yielded());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeYieldOp::yielded"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeYieldOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeYieldOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypeYieldOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1440]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TypeYieldOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TypeYieldOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypeYieldOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypeYieldOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypeYieldOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/TypedefType.cpp b/bindings/Python/Generated/IR/HighLevel/TypedefType.cpp
deleted file mode 100644
index 33a1c55fb..000000000
--- a/bindings/Python/Generated/IR/HighLevel/TypedefType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::TypedefType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1499]) || tp >= &(gTypes[1500])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::TypedefType::static_kind():
-      tp = &(gTypes[1499]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TypedefType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypedefType::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypedefType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::TypedefType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1499]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.TypedefType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::TypedefType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TypedefType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TypedefType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TypedefType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/UCVQualifiersAttr.cpp b/bindings/Python/Generated/IR/HighLevel/UCVQualifiersAttr.cpp
deleted file mode 100644
index 43bcabdd2..000000000
--- a/bindings/Python/Generated/IR/HighLevel/UCVQualifiersAttr.cpp
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::UCVQualifiersAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[981]) || tp >= &(gTypes[982])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::UCVQualifiersAttr::static_kind():
-      tp = &(gTypes[981]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UCVQualifiersAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_unsigned",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_unsigned());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::UCVQualifiersAttr::is_unsigned"),
-    nullptr,
-  },
-  {
-    "is_const",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_const());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::UCVQualifiersAttr::is_const"),
-    nullptr,
-  },
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::UCVQualifiersAttr::is_volatile"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UCVQualifiersAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UCVQualifiersAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[981]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.UCVQualifiersAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::UCVQualifiersAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UCVQualifiersAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UCVQualifiersAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UCVQualifiersAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/UnionDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/UnionDeclOp.cpp
deleted file mode 100644
index c3d609714..000000000
--- a/bindings/Python/Generated/IR/HighLevel/UnionDeclOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::UnionDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1441]) || tp >= &(gTypes[1442])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::UnionDeclOp::static_kind():
-      tp = &(gTypes[1441]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnionDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "fields",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->fields());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnionDeclOp::fields"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnionDeclOp::name"),
-    nullptr,
-  },
-  {
-    "field_types",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::field_types);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnionDeclOp::field_types"),
-    nullptr,
-  },
-  {
-    "defined_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->defined_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnionDeclOp::defined_type"),
-    nullptr,
-  },
-  {
-    "is_complete_definition",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_complete_definition());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnionDeclOp::is_complete_definition"),
-    nullptr,
-  },
-  {
-    "fields_block",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->fields_block());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnionDeclOp::fields_block"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnionDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnionDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnionDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1441]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.UnionDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::UnionDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnionDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnionDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnionDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/UnreachableOp.cpp b/bindings/Python/Generated/IR/HighLevel/UnreachableOp.cpp
deleted file mode 100644
index cfc11e940..000000000
--- a/bindings/Python/Generated/IR/HighLevel/UnreachableOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::UnreachableOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1442]) || tp >= &(gTypes[1443])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::UnreachableOp::static_kind():
-      tp = &(gTypes[1442]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnreachableOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnreachableOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnreachableOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnreachableOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1442]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.UnreachableOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::UnreachableOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnreachableOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnreachableOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnreachableOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/UnusedAttr.cpp b/bindings/Python/Generated/IR/HighLevel/UnusedAttr.cpp
deleted file mode 100644
index b1571a1ce..000000000
--- a/bindings/Python/Generated/IR/HighLevel/UnusedAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::UnusedAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[963]) || tp >= &(gTypes[964])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::UnusedAttr::static_kind():
-      tp = &(gTypes[963]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnusedAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnusedAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UnusedAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[963]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.UnusedAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::UnusedAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnusedAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnusedAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnusedAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/UsedAttr.cpp b/bindings/Python/Generated/IR/HighLevel/UsedAttr.cpp
deleted file mode 100644
index d80386f63..000000000
--- a/bindings/Python/Generated/IR/HighLevel/UsedAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::UsedAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[964]) || tp >= &(gTypes[965])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::UsedAttr::static_kind():
-      tp = &(gTypes[964]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UsedAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UsedAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::UsedAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[964]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.UsedAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::UsedAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UsedAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UsedAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UsedAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/VAArgExprOp.cpp b/bindings/Python/Generated/IR/HighLevel/VAArgExprOp.cpp
deleted file mode 100644
index 8c8e3f831..000000000
--- a/bindings/Python/Generated/IR/HighLevel/VAArgExprOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::VAArgExprOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1443]) || tp >= &(gTypes[1444])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::VAArgExprOp::static_kind():
-      tp = &(gTypes[1443]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VAArgExprOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument_list",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument_list());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VAArgExprOp::argument_list"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VAArgExprOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VAArgExprOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VAArgExprOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VAArgExprOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1443]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.VAArgExprOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::VAArgExprOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VAArgExprOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VAArgExprOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VAArgExprOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/ValueYieldOp.cpp b/bindings/Python/Generated/IR/HighLevel/ValueYieldOp.cpp
deleted file mode 100644
index abb482ba8..000000000
--- a/bindings/Python/Generated/IR/HighLevel/ValueYieldOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::ValueYieldOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1444]) || tp >= &(gTypes[1445])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::ValueYieldOp::static_kind():
-      tp = &(gTypes[1444]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ValueYieldOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::ValueYieldOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ValueYieldOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ValueYieldOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::ValueYieldOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1444]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.ValueYieldOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::ValueYieldOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ValueYieldOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ValueYieldOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ValueYieldOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/VarDeclOp.cpp b/bindings/Python/Generated/IR/HighLevel/VarDeclOp.cpp
deleted file mode 100644
index 591edeae6..000000000
--- a/bindings/Python/Generated/IR/HighLevel/VarDeclOp.cpp
+++ /dev/null
@@ -1,395 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::VarDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1445]) || tp >= &(gTypes[1446])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::VarDeclOp::static_kind():
-      tp = &(gTypes[1445]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VarDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::result"),
-    nullptr,
-  },
-  {
-    "initializer",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->initializer());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::initializer"),
-    nullptr,
-  },
-  {
-    "allocation_size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->allocation_size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::allocation_size"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::name"),
-    nullptr,
-  },
-  {
-    "has_local_storage",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->has_local_storage());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::has_local_storage"),
-    nullptr,
-  },
-  {
-    "is_local_variable_declaration",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_local_variable_declaration());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::is_local_variable_declaration"),
-    nullptr,
-  },
-  {
-    "is_static_local_variable_declaration",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_static_local_variable_declaration());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::is_static_local_variable_declaration"),
-    nullptr,
-  },
-  {
-    "has_external_storage",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->has_external_storage());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::has_external_storage"),
-    nullptr,
-  },
-  {
-    "has_global_storage",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->has_global_storage());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::has_global_storage"),
-    nullptr,
-  },
-  {
-    "is_static_data_member",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_static_data_member());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::is_static_data_member"),
-    nullptr,
-  },
-  {
-    "is_in_file_context",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_in_file_context());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::is_in_file_context"),
-    nullptr,
-  },
-  {
-    "is_in_function_or_method_context",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_in_function_or_method_context());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::is_in_function_or_method_context"),
-    nullptr,
-  },
-  {
-    "is_in_record_context",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_in_record_context());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::is_in_record_context"),
-    nullptr,
-  },
-  {
-    "is_file_variable_declaration",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_file_variable_declaration());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::is_file_variable_declaration"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VarDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1445]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.VarDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::VarDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VarDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VarDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VarDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/VectorType.cpp b/bindings/Python/Generated/IR/HighLevel/VectorType.cpp
deleted file mode 100644
index 763833f42..000000000
--- a/bindings/Python/Generated/IR/HighLevel/VectorType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::VectorType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1522]) || tp >= &(gTypes[1523])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::VectorType::static_kind():
-      tp = &(gTypes[1522]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VectorType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VectorType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1522]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.VectorType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::VectorType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/VisibilityAttr.cpp b/bindings/Python/Generated/IR/HighLevel/VisibilityAttr.cpp
deleted file mode 100644
index 4e9be15f3..000000000
--- a/bindings/Python/Generated/IR/HighLevel/VisibilityAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::VisibilityAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[978]) || tp >= &(gTypes[979])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::VisibilityAttr::static_kind():
-      tp = &(gTypes[978]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VisibilityAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VisibilityAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VisibilityAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[978]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.VisibilityAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::VisibilityAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VisibilityAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VisibilityAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VisibilityAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/VoidType.cpp b/bindings/Python/Generated/IR/HighLevel/VoidType.cpp
deleted file mode 100644
index 922163ccc..000000000
--- a/bindings/Python/Generated/IR/HighLevel/VoidType.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::VoidType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1505]) || tp >= &(gTypes[1506])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::VoidType::static_kind():
-      tp = &(gTypes[1505]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VoidType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VoidType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::VoidType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1505]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.VoidType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::VoidType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1496].tp_hash;
-  tp->tp_richcompare = gTypes[1496].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1496]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VoidType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VoidType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VoidType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/WarnUnusedResultAttr.cpp b/bindings/Python/Generated/IR/HighLevel/WarnUnusedResultAttr.cpp
deleted file mode 100644
index 0c9d7b412..000000000
--- a/bindings/Python/Generated/IR/HighLevel/WarnUnusedResultAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::WarnUnusedResultAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[954]) || tp >= &(gTypes[955])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::WarnUnusedResultAttr::static_kind():
-      tp = &(gTypes[954]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "WarnUnusedResultAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::WarnUnusedResultAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::WarnUnusedResultAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[954]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.WarnUnusedResultAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::WarnUnusedResultAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[938].tp_hash;
-  tp->tp_richcompare = gTypes[938].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[938]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'WarnUnusedResultAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'WarnUnusedResultAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'WarnUnusedResultAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/HighLevel/WhileOp.cpp b/bindings/Python/Generated/IR/HighLevel/WhileOp.cpp
deleted file mode 100644
index 37be65461..000000000
--- a/bindings/Python/Generated/IR/HighLevel/WhileOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::hl::WhileOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1446]) || tp >= &(gTypes[1447])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::hl::WhileOp::static_kind():
-      tp = &(gTypes[1446]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "WhileOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "condition_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->condition_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::WhileOp::condition_region"),
-    nullptr,
-  },
-  {
-    "body_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::hl::WhileOp::body_region"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::WhileOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::WhileOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::hl::WhileOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1446]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.highlevel.WhileOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::hl::::WhileOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1315].tp_hash;
-  tp->tp_richcompare = gTypes[1315].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1315]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'WhileOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'WhileOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'WhileOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AShrOp.cpp b/bindings/Python/Generated/IR/LLVM/AShrOp.cpp
deleted file mode 100644
index 8ad3253f2..000000000
--- a/bindings/Python/Generated/IR/LLVM/AShrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AShrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1003]) || tp >= &(gTypes[1004])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AShrOp::static_kind():
-      tp = &(gTypes[1003]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AShrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AShrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AShrOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AShrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AShrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AShrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AShrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1003]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AShrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AShrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AShrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AShrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AShrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AbsOp.cpp b/bindings/Python/Generated/IR/LLVM/AbsOp.cpp
deleted file mode 100644
index f95d9ea47..000000000
--- a/bindings/Python/Generated/IR/LLVM/AbsOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AbsOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1075]) || tp >= &(gTypes[1076])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AbsOp::static_kind():
-      tp = &(gTypes[1075]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AbsOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AbsOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AbsOp::result"),
-    nullptr,
-  },
-  {
-    "is_int_min_poison",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_int_min_poison());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AbsOp::is_int_min_poison"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AbsOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AbsOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AbsOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1075]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AbsOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AbsOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AbsOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AbsOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AbsOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AccessGroupAttr.cpp b/bindings/Python/Generated/IR/LLVM/AccessGroupAttr.cpp
deleted file mode 100644
index 3ba5d0b97..000000000
--- a/bindings/Python/Generated/IR/LLVM/AccessGroupAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AccessGroupAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[929]) || tp >= &(gTypes[930])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AccessGroupAttr::static_kind():
-      tp = &(gTypes[929]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AccessGroupAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AccessGroupAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AccessGroupAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[929]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AccessGroupAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AccessGroupAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AccessGroupAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AccessGroupAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AccessGroupAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AddOp.cpp b/bindings/Python/Generated/IR/LLVM/AddOp.cpp
deleted file mode 100644
index 74b605d29..000000000
--- a/bindings/Python/Generated/IR/LLVM/AddOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1004]) || tp >= &(gTypes[1005])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AddOp::static_kind():
-      tp = &(gTypes[1004]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1004]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AddrSpaceCastOp.cpp b/bindings/Python/Generated/IR/LLVM/AddrSpaceCastOp.cpp
deleted file mode 100644
index abfeae5c1..000000000
--- a/bindings/Python/Generated/IR/LLVM/AddrSpaceCastOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AddrSpaceCastOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1005]) || tp >= &(gTypes[1006])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AddrSpaceCastOp::static_kind():
-      tp = &(gTypes[1005]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AddrSpaceCastOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddrSpaceCastOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddrSpaceCastOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddrSpaceCastOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddrSpaceCastOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddrSpaceCastOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1005]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AddrSpaceCastOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AddrSpaceCastOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AddrSpaceCastOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AddrSpaceCastOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AddrSpaceCastOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AddressOfOp.cpp b/bindings/Python/Generated/IR/LLVM/AddressOfOp.cpp
deleted file mode 100644
index 93ecafcf1..000000000
--- a/bindings/Python/Generated/IR/LLVM/AddressOfOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AddressOfOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1006]) || tp >= &(gTypes[1007])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AddressOfOp::static_kind():
-      tp = &(gTypes[1006]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AddressOfOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "global_name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->global_name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddressOfOp::global_name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddressOfOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddressOfOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AddressOfOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1006]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AddressOfOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AddressOfOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AddressOfOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AddressOfOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AddressOfOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AliasScopeAttr.cpp b/bindings/Python/Generated/IR/LLVM/AliasScopeAttr.cpp
deleted file mode 100644
index 4095bcad0..000000000
--- a/bindings/Python/Generated/IR/LLVM/AliasScopeAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AliasScopeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[928]) || tp >= &(gTypes[929])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AliasScopeAttr::static_kind():
-      tp = &(gTypes[928]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AliasScopeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AliasScopeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AliasScopeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[928]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AliasScopeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AliasScopeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AliasScopeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AliasScopeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AliasScopeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AliasScopeDomainAttr.cpp b/bindings/Python/Generated/IR/LLVM/AliasScopeDomainAttr.cpp
deleted file mode 100644
index d51cb2536..000000000
--- a/bindings/Python/Generated/IR/LLVM/AliasScopeDomainAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AliasScopeDomainAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[927]) || tp >= &(gTypes[928])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AliasScopeDomainAttr::static_kind():
-      tp = &(gTypes[927]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AliasScopeDomainAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AliasScopeDomainAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AliasScopeDomainAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[927]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AliasScopeDomainAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AliasScopeDomainAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AliasScopeDomainAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AliasScopeDomainAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AliasScopeDomainAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AllocaOp.cpp b/bindings/Python/Generated/IR/LLVM/AllocaOp.cpp
deleted file mode 100644
index 2fb32eba6..000000000
--- a/bindings/Python/Generated/IR/LLVM/AllocaOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AllocaOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1007]) || tp >= &(gTypes[1008])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AllocaOp::static_kind():
-      tp = &(gTypes[1007]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AllocaOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AllocaOp::alignment"),
-    nullptr,
-  },
-  {
-    "elem_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->elem_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AllocaOp::elem_type"),
-    nullptr,
-  },
-  {
-    "inalloca",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->inalloca());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AllocaOp::inalloca"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AllocaOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AllocaOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AllocaOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1007]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AllocaOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AllocaOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AllocaOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AllocaOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AllocaOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AndOp.cpp b/bindings/Python/Generated/IR/LLVM/AndOp.cpp
deleted file mode 100644
index 6d1d95969..000000000
--- a/bindings/Python/Generated/IR/LLVM/AndOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1008]) || tp >= &(gTypes[1009])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AndOp::static_kind():
-      tp = &(gTypes[1008]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AndOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AndOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AndOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1008]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AnnotationOp.cpp b/bindings/Python/Generated/IR/LLVM/AnnotationOp.cpp
deleted file mode 100644
index d045f1c1b..000000000
--- a/bindings/Python/Generated/IR/LLVM/AnnotationOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AnnotationOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1076]) || tp >= &(gTypes[1077])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AnnotationOp::static_kind():
-      tp = &(gTypes[1076]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AnnotationOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AnnotationOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AnnotationOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AnnotationOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1076]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AnnotationOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AnnotationOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AnnotationOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AnnotationOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AnnotationOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ArrayType.cpp b/bindings/Python/Generated/IR/LLVM/ArrayType.cpp
deleted file mode 100644
index 038190c95..000000000
--- a/bindings/Python/Generated/IR/LLVM/ArrayType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ArrayType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1490]) || tp >= &(gTypes[1491])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ArrayType::static_kind():
-      tp = &(gTypes[1490]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ArrayType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "num_elements",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_elements());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ArrayType::num_elements"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ArrayType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ArrayType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1490]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ArrayType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ArrayType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1489].tp_hash;
-  tp->tp_richcompare = gTypes[1489].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1489]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ArrayType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ArrayType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ArrayType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AssumeOp.cpp b/bindings/Python/Generated/IR/LLVM/AssumeOp.cpp
deleted file mode 100644
index e2d870121..000000000
--- a/bindings/Python/Generated/IR/LLVM/AssumeOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AssumeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1077]) || tp >= &(gTypes[1078])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AssumeOp::static_kind():
-      tp = &(gTypes[1077]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AssumeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AssumeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AssumeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AssumeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1077]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AssumeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AssumeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AssumeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AssumeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AssumeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AtomicCmpXchgOp.cpp b/bindings/Python/Generated/IR/LLVM/AtomicCmpXchgOp.cpp
deleted file mode 100644
index 6b734a8d1..000000000
--- a/bindings/Python/Generated/IR/LLVM/AtomicCmpXchgOp.cpp
+++ /dev/null
@@ -1,325 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AtomicCmpXchgOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1009]) || tp >= &(gTypes[1010])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AtomicCmpXchgOp::static_kind():
-      tp = &(gTypes[1009]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AtomicCmpXchgOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "cmp",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->cmp());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::cmp"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::result"),
-    nullptr,
-  },
-  {
-    "syncscope",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->syncscope());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::syncscope"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::alignment"),
-    nullptr,
-  },
-  {
-    "weak",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->weak());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::weak"),
-    nullptr,
-  },
-  {
-    "volatile__",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->volatile__());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::volatile__"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicCmpXchgOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1009]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AtomicCmpXchgOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AtomicCmpXchgOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AtomicCmpXchgOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AtomicCmpXchgOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AtomicCmpXchgOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/AtomicRMWOp.cpp b/bindings/Python/Generated/IR/LLVM/AtomicRMWOp.cpp
deleted file mode 100644
index c57f09c6d..000000000
--- a/bindings/Python/Generated/IR/LLVM/AtomicRMWOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::AtomicRMWOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1010]) || tp >= &(gTypes[1011])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AtomicRMWOp::static_kind():
-      tp = &(gTypes[1010]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AtomicRMWOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicRMWOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicRMWOp::result"),
-    nullptr,
-  },
-  {
-    "syncscope",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->syncscope());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicRMWOp::syncscope"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicRMWOp::alignment"),
-    nullptr,
-  },
-  {
-    "volatile__",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->volatile__());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicRMWOp::volatile__"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicRMWOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicRMWOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::AtomicRMWOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1010]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.AtomicRMWOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::AtomicRMWOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AtomicRMWOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AtomicRMWOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AtomicRMWOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/Attribute.cpp b/bindings/Python/Generated/IR/LLVM/Attribute.cpp
deleted file mode 100644
index a689c18c1..000000000
--- a/bindings/Python/Generated/IR/LLVM/Attribute.cpp
+++ /dev/null
@@ -1,393 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::Attribute;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[892]) || tp >= &(gTypes[938])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CConvAttr::static_kind():
-      tp = &(gTypes[893]);
-      break;
-
-    case mx::ir::llvm::ComdatAttr::static_kind():
-      tp = &(gTypes[894]);
-      break;
-
-    case mx::ir::llvm::LinkageAttr::static_kind():
-      tp = &(gTypes[895]);
-      break;
-
-    case mx::ir::llvm::FramePointerKindAttr::static_kind():
-      tp = &(gTypes[896]);
-      break;
-
-    case mx::ir::llvm::LoopVectorizeAttr::static_kind():
-      tp = &(gTypes[897]);
-      break;
-
-    case mx::ir::llvm::LoopInterleaveAttr::static_kind():
-      tp = &(gTypes[898]);
-      break;
-
-    case mx::ir::llvm::LoopUnrollAttr::static_kind():
-      tp = &(gTypes[899]);
-      break;
-
-    case mx::ir::llvm::LoopUnrollAndJamAttr::static_kind():
-      tp = &(gTypes[900]);
-      break;
-
-    case mx::ir::llvm::LoopLICMAttr::static_kind():
-      tp = &(gTypes[901]);
-      break;
-
-    case mx::ir::llvm::LoopDistributeAttr::static_kind():
-      tp = &(gTypes[902]);
-      break;
-
-    case mx::ir::llvm::LoopPipelineAttr::static_kind():
-      tp = &(gTypes[903]);
-      break;
-
-    case mx::ir::llvm::LoopPeeledAttr::static_kind():
-      tp = &(gTypes[904]);
-      break;
-
-    case mx::ir::llvm::LoopUnswitchAttr::static_kind():
-      tp = &(gTypes[905]);
-      break;
-
-    case mx::ir::llvm::LoopAnnotationAttr::static_kind():
-      tp = &(gTypes[906]);
-      break;
-
-    case mx::ir::llvm::DIExpressionElemAttr::static_kind():
-      tp = &(gTypes[907]);
-      break;
-
-    case mx::ir::llvm::DIExpressionAttr::static_kind():
-      tp = &(gTypes[908]);
-      break;
-
-    case mx::ir::llvm::DINullTypeAttr::static_kind():
-      tp = &(gTypes[909]);
-      break;
-
-    case mx::ir::llvm::DIBasicTypeAttr::static_kind():
-      tp = &(gTypes[910]);
-      break;
-
-    case mx::ir::llvm::DICompileUnitAttr::static_kind():
-      tp = &(gTypes[911]);
-      break;
-
-    case mx::ir::llvm::DICompositeTypeAttr::static_kind():
-      tp = &(gTypes[912]);
-      break;
-
-    case mx::ir::llvm::DIDerivedTypeAttr::static_kind():
-      tp = &(gTypes[913]);
-      break;
-
-    case mx::ir::llvm::DIFileAttr::static_kind():
-      tp = &(gTypes[914]);
-      break;
-
-    case mx::ir::llvm::DIGlobalVariableExpressionAttr::static_kind():
-      tp = &(gTypes[915]);
-      break;
-
-    case mx::ir::llvm::DIGlobalVariableAttr::static_kind():
-      tp = &(gTypes[916]);
-      break;
-
-    case mx::ir::llvm::DILexicalBlockAttr::static_kind():
-      tp = &(gTypes[917]);
-      break;
-
-    case mx::ir::llvm::DILexicalBlockFileAttr::static_kind():
-      tp = &(gTypes[918]);
-      break;
-
-    case mx::ir::llvm::DILocalVariableAttr::static_kind():
-      tp = &(gTypes[919]);
-      break;
-
-    case mx::ir::llvm::DISubprogramAttr::static_kind():
-      tp = &(gTypes[920]);
-      break;
-
-    case mx::ir::llvm::DIModuleAttr::static_kind():
-      tp = &(gTypes[921]);
-      break;
-
-    case mx::ir::llvm::DINamespaceAttr::static_kind():
-      tp = &(gTypes[922]);
-      break;
-
-    case mx::ir::llvm::DISubrangeAttr::static_kind():
-      tp = &(gTypes[923]);
-      break;
-
-    case mx::ir::llvm::DISubroutineTypeAttr::static_kind():
-      tp = &(gTypes[924]);
-      break;
-
-    case mx::ir::llvm::DILabelAttr::static_kind():
-      tp = &(gTypes[925]);
-      break;
-
-    case mx::ir::llvm::MemoryEffectsAttr::static_kind():
-      tp = &(gTypes[926]);
-      break;
-
-    case mx::ir::llvm::AliasScopeDomainAttr::static_kind():
-      tp = &(gTypes[927]);
-      break;
-
-    case mx::ir::llvm::AliasScopeAttr::static_kind():
-      tp = &(gTypes[928]);
-      break;
-
-    case mx::ir::llvm::AccessGroupAttr::static_kind():
-      tp = &(gTypes[929]);
-      break;
-
-    case mx::ir::llvm::TBAARootAttr::static_kind():
-      tp = &(gTypes[930]);
-      break;
-
-    case mx::ir::llvm::TBAAMemberAttr::static_kind():
-      tp = &(gTypes[931]);
-      break;
-
-    case mx::ir::llvm::TBAATypeDescriptorAttr::static_kind():
-      tp = &(gTypes[932]);
-      break;
-
-    case mx::ir::llvm::TBAATagAttr::static_kind():
-      tp = &(gTypes[933]);
-      break;
-
-    case mx::ir::llvm::VScaleRangeAttr::static_kind():
-      tp = &(gTypes[934]);
-      break;
-
-    case mx::ir::llvm::TargetFeaturesAttr::static_kind():
-      tp = &(gTypes[935]);
-      break;
-
-    case mx::ir::llvm::IntegerOverflowFlagsAttr::static_kind():
-      tp = &(gTypes[936]);
-      break;
-
-    case mx::ir::llvm::FastmathFlagsAttr::static_kind():
-      tp = &(gTypes[937]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Attribute", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Attribute::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[892]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.Attribute";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::Attribute");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[867].tp_hash;
-  tp->tp_richcompare = gTypes[867].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[867]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Attribute.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Attribute.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Attribute' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/BitReverseOp.cpp b/bindings/Python/Generated/IR/LLVM/BitReverseOp.cpp
deleted file mode 100644
index d8fda2ab3..000000000
--- a/bindings/Python/Generated/IR/LLVM/BitReverseOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::BitReverseOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1078]) || tp >= &(gTypes[1079])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::BitReverseOp::static_kind():
-      tp = &(gTypes[1078]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BitReverseOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitReverseOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitReverseOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitReverseOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitReverseOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitReverseOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1078]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.BitReverseOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::BitReverseOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BitReverseOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BitReverseOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BitReverseOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/BitcastOp.cpp b/bindings/Python/Generated/IR/LLVM/BitcastOp.cpp
deleted file mode 100644
index 4f3c4a3e9..000000000
--- a/bindings/Python/Generated/IR/LLVM/BitcastOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::BitcastOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1011]) || tp >= &(gTypes[1012])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::BitcastOp::static_kind():
-      tp = &(gTypes[1011]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BitcastOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitcastOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitcastOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitcastOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitcastOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BitcastOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1011]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.BitcastOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::BitcastOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BitcastOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BitcastOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BitcastOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/BrOp.cpp b/bindings/Python/Generated/IR/LLVM/BrOp.cpp
deleted file mode 100644
index 892a645aa..000000000
--- a/bindings/Python/Generated/IR/LLVM/BrOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::BrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1012]) || tp >= &(gTypes[1013])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::BrOp::static_kind():
-      tp = &(gTypes[1012]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "dest_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::dest_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BrOp::dest_operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::BrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1012]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.BrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::BrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ByteSwapOp.cpp b/bindings/Python/Generated/IR/LLVM/ByteSwapOp.cpp
deleted file mode 100644
index 8a3f10a20..000000000
--- a/bindings/Python/Generated/IR/LLVM/ByteSwapOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ByteSwapOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1079]) || tp >= &(gTypes[1080])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ByteSwapOp::static_kind():
-      tp = &(gTypes[1079]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ByteSwapOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ByteSwapOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ByteSwapOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ByteSwapOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ByteSwapOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ByteSwapOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1079]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ByteSwapOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ByteSwapOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ByteSwapOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ByteSwapOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ByteSwapOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CConvAttr.cpp b/bindings/Python/Generated/IR/LLVM/CConvAttr.cpp
deleted file mode 100644
index c66c0a112..000000000
--- a/bindings/Python/Generated/IR/LLVM/CConvAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CConvAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[893]) || tp >= &(gTypes[894])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CConvAttr::static_kind():
-      tp = &(gTypes[893]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CConvAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CConvAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CConvAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[893]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CConvAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CConvAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CConvAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CConvAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CConvAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CallIntrinsicOp.cpp b/bindings/Python/Generated/IR/LLVM/CallIntrinsicOp.cpp
deleted file mode 100644
index 5a5d64dea..000000000
--- a/bindings/Python/Generated/IR/LLVM/CallIntrinsicOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CallIntrinsicOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1013]) || tp >= &(gTypes[1014])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CallIntrinsicOp::static_kind():
-      tp = &(gTypes[1013]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CallIntrinsicOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "arguments",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arguments);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallIntrinsicOp::arguments"),
-    nullptr,
-  },
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->results());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallIntrinsicOp::results"),
-    nullptr,
-  },
-  {
-    "intrin",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->intrin());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallIntrinsicOp::intrin"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallIntrinsicOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallIntrinsicOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallIntrinsicOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1013]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CallIntrinsicOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CallIntrinsicOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CallIntrinsicOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CallIntrinsicOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CallIntrinsicOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CallOp.cpp b/bindings/Python/Generated/IR/LLVM/CallOp.cpp
deleted file mode 100644
index 9d0ea2d11..000000000
--- a/bindings/Python/Generated/IR/LLVM/CallOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CallOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1014]) || tp >= &(gTypes[1015])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CallOp::static_kind():
-      tp = &(gTypes[1014]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CallOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "callee_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::callee_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallOp::callee_operands"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallOp::result"),
-    nullptr,
-  },
-  {
-    "callee",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->callee());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallOp::callee"),
-    nullptr,
-  },
-  {
-    "arg_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arg_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallOp::arg_operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CallOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1014]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CallOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CallOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CallOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CallOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CallOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ComdatAttr.cpp b/bindings/Python/Generated/IR/LLVM/ComdatAttr.cpp
deleted file mode 100644
index be61155a4..000000000
--- a/bindings/Python/Generated/IR/LLVM/ComdatAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ComdatAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[894]) || tp >= &(gTypes[895])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ComdatAttr::static_kind():
-      tp = &(gTypes[894]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ComdatAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[894]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ComdatAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ComdatAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ComdatAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ComdatAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ComdatAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ComdatOp.cpp b/bindings/Python/Generated/IR/LLVM/ComdatOp.cpp
deleted file mode 100644
index 8feaac081..000000000
--- a/bindings/Python/Generated/IR/LLVM/ComdatOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ComdatOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1015]) || tp >= &(gTypes[1016])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ComdatOp::static_kind():
-      tp = &(gTypes[1015]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ComdatOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatOp::body"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatOp::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1015]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ComdatOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ComdatOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ComdatOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ComdatOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ComdatOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ComdatSelectorOp.cpp b/bindings/Python/Generated/IR/LLVM/ComdatSelectorOp.cpp
deleted file mode 100644
index f27ab56fb..000000000
--- a/bindings/Python/Generated/IR/LLVM/ComdatSelectorOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ComdatSelectorOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1016]) || tp >= &(gTypes[1017])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ComdatSelectorOp::static_kind():
-      tp = &(gTypes[1016]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ComdatSelectorOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatSelectorOp::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatSelectorOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatSelectorOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ComdatSelectorOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1016]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ComdatSelectorOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ComdatSelectorOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ComdatSelectorOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ComdatSelectorOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ComdatSelectorOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CondBrOp.cpp b/bindings/Python/Generated/IR/LLVM/CondBrOp.cpp
deleted file mode 100644
index f4195b91e..000000000
--- a/bindings/Python/Generated/IR/LLVM/CondBrOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CondBrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1017]) || tp >= &(gTypes[1018])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CondBrOp::static_kind():
-      tp = &(gTypes[1017]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CondBrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "true_dest_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::true_dest_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CondBrOp::true_dest_operands"),
-    nullptr,
-  },
-  {
-    "false_dest_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::false_dest_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CondBrOp::false_dest_operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CondBrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CondBrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CondBrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1017]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CondBrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CondBrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CondBrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CondBrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CondBrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ConstantOp.cpp b/bindings/Python/Generated/IR/LLVM/ConstantOp.cpp
deleted file mode 100644
index 03e293467..000000000
--- a/bindings/Python/Generated/IR/LLVM/ConstantOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ConstantOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1018]) || tp >= &(gTypes[1019])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ConstantOp::static_kind():
-      tp = &(gTypes[1018]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ConstantOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ConstantOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ConstantOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ConstantOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ConstantOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1018]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ConstantOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ConstantOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ConstantOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ConstantOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ConstantOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CopySignOp.cpp b/bindings/Python/Generated/IR/LLVM/CopySignOp.cpp
deleted file mode 100644
index 5cf5ec07a..000000000
--- a/bindings/Python/Generated/IR/LLVM/CopySignOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CopySignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1080]) || tp >= &(gTypes[1081])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CopySignOp::static_kind():
-      tp = &(gTypes[1080]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CopySignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CopySignOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CopySignOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CopySignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CopySignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CopySignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CopySignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1080]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CopySignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CopySignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CopySignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CopySignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CopySignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroAlignOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroAlignOp.cpp
deleted file mode 100644
index 707993ac8..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroAlignOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroAlignOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1081]) || tp >= &(gTypes[1082])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroAlignOp::static_kind():
-      tp = &(gTypes[1081]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroAlignOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroAlignOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroAlignOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroAlignOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroAlignOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1081]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroAlignOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroAlignOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroAlignOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroAlignOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroAlignOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroBeginOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroBeginOp.cpp
deleted file mode 100644
index 6370a4190..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroBeginOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroBeginOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1082]) || tp >= &(gTypes[1083])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroBeginOp::static_kind():
-      tp = &(gTypes[1082]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroBeginOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "token",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->token());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroBeginOp::token"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroBeginOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroBeginOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroBeginOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroBeginOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1082]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroBeginOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroBeginOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroBeginOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroBeginOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroBeginOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroEndOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroEndOp.cpp
deleted file mode 100644
index 0e6464427..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroEndOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroEndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1083]) || tp >= &(gTypes[1084])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroEndOp::static_kind():
-      tp = &(gTypes[1083]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroEndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "retvals",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->retvals());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroEndOp::retvals"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroEndOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroEndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroEndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroEndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1083]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroEndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroEndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroEndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroEndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroEndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroFreeOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroFreeOp.cpp
deleted file mode 100644
index a18989b69..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroFreeOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroFreeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1084]) || tp >= &(gTypes[1085])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroFreeOp::static_kind():
-      tp = &(gTypes[1084]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroFreeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "id",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->id());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroFreeOp::id"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroFreeOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroFreeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroFreeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroFreeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1084]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroFreeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroFreeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroFreeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroFreeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroFreeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroIdOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroIdOp.cpp
deleted file mode 100644
index 8b7c2d465..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroIdOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroIdOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1085]) || tp >= &(gTypes[1086])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroIdOp::static_kind():
-      tp = &(gTypes[1085]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroIdOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroIdOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroIdOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroIdOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroIdOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1085]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroIdOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroIdOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroIdOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroIdOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroIdOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroPromiseOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroPromiseOp.cpp
deleted file mode 100644
index e94268f87..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroPromiseOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroPromiseOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1086]) || tp >= &(gTypes[1087])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroPromiseOp::static_kind():
-      tp = &(gTypes[1086]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroPromiseOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroPromiseOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroPromiseOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroPromiseOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1086]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroPromiseOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroPromiseOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroPromiseOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroPromiseOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroPromiseOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroResumeOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroResumeOp.cpp
deleted file mode 100644
index 252c47e73..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroResumeOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroResumeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1087]) || tp >= &(gTypes[1088])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroResumeOp::static_kind():
-      tp = &(gTypes[1087]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroResumeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroResumeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroResumeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroResumeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1087]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroResumeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroResumeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroResumeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroResumeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroResumeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroSaveOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroSaveOp.cpp
deleted file mode 100644
index a612ff777..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroSaveOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroSaveOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1088]) || tp >= &(gTypes[1089])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroSaveOp::static_kind():
-      tp = &(gTypes[1088]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroSaveOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSaveOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSaveOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSaveOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSaveOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1088]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroSaveOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroSaveOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroSaveOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroSaveOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroSaveOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroSizeOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroSizeOp.cpp
deleted file mode 100644
index 5457579e5..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroSizeOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroSizeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1089]) || tp >= &(gTypes[1090])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroSizeOp::static_kind():
-      tp = &(gTypes[1089]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroSizeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSizeOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSizeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSizeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSizeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1089]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroSizeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroSizeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroSizeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroSizeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroSizeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CoroSuspendOp.cpp b/bindings/Python/Generated/IR/LLVM/CoroSuspendOp.cpp
deleted file mode 100644
index 7a7f2ea2c..000000000
--- a/bindings/Python/Generated/IR/LLVM/CoroSuspendOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CoroSuspendOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1090]) || tp >= &(gTypes[1091])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CoroSuspendOp::static_kind():
-      tp = &(gTypes[1090]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CoroSuspendOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "save",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->save());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSuspendOp::save"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSuspendOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSuspendOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSuspendOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CoroSuspendOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1090]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CoroSuspendOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CoroSuspendOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CoroSuspendOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CoroSuspendOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CoroSuspendOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CosOp.cpp b/bindings/Python/Generated/IR/LLVM/CosOp.cpp
deleted file mode 100644
index 47747747c..000000000
--- a/bindings/Python/Generated/IR/LLVM/CosOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CosOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1091]) || tp >= &(gTypes[1092])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CosOp::static_kind():
-      tp = &(gTypes[1091]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CosOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CosOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CosOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CosOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CosOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CosOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1091]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CosOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CosOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CosOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CosOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CosOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CountLeadingZerosOp.cpp b/bindings/Python/Generated/IR/LLVM/CountLeadingZerosOp.cpp
deleted file mode 100644
index 785a77e02..000000000
--- a/bindings/Python/Generated/IR/LLVM/CountLeadingZerosOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CountLeadingZerosOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1092]) || tp >= &(gTypes[1093])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CountLeadingZerosOp::static_kind():
-      tp = &(gTypes[1092]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CountLeadingZerosOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountLeadingZerosOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountLeadingZerosOp::result"),
-    nullptr,
-  },
-  {
-    "is_zero_poison",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_zero_poison());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountLeadingZerosOp::is_zero_poison"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountLeadingZerosOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountLeadingZerosOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountLeadingZerosOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1092]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CountLeadingZerosOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CountLeadingZerosOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CountLeadingZerosOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CountLeadingZerosOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CountLeadingZerosOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CountTrailingZerosOp.cpp b/bindings/Python/Generated/IR/LLVM/CountTrailingZerosOp.cpp
deleted file mode 100644
index efce52d35..000000000
--- a/bindings/Python/Generated/IR/LLVM/CountTrailingZerosOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CountTrailingZerosOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1093]) || tp >= &(gTypes[1094])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CountTrailingZerosOp::static_kind():
-      tp = &(gTypes[1093]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CountTrailingZerosOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountTrailingZerosOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountTrailingZerosOp::result"),
-    nullptr,
-  },
-  {
-    "is_zero_poison",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_zero_poison());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountTrailingZerosOp::is_zero_poison"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountTrailingZerosOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountTrailingZerosOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CountTrailingZerosOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1093]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CountTrailingZerosOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CountTrailingZerosOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CountTrailingZerosOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CountTrailingZerosOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CountTrailingZerosOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/CtPopOp.cpp b/bindings/Python/Generated/IR/LLVM/CtPopOp.cpp
deleted file mode 100644
index 352a25d12..000000000
--- a/bindings/Python/Generated/IR/LLVM/CtPopOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::CtPopOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1094]) || tp >= &(gTypes[1095])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::CtPopOp::static_kind():
-      tp = &(gTypes[1094]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CtPopOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CtPopOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CtPopOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CtPopOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CtPopOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::CtPopOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1094]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.CtPopOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::CtPopOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CtPopOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CtPopOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CtPopOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DIBasicTypeAttr.cpp b/bindings/Python/Generated/IR/LLVM/DIBasicTypeAttr.cpp
deleted file mode 100644
index 4122a174d..000000000
--- a/bindings/Python/Generated/IR/LLVM/DIBasicTypeAttr.cpp
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DIBasicTypeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[910]) || tp >= &(gTypes[911])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DIBasicTypeAttr::static_kind():
-      tp = &(gTypes[910]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DIBasicTypeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "tag",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->tag());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIBasicTypeAttr::tag"),
-    nullptr,
-  },
-  {
-    "size_in_bits",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size_in_bits());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIBasicTypeAttr::size_in_bits"),
-    nullptr,
-  },
-  {
-    "encoding",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->encoding());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIBasicTypeAttr::encoding"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIBasicTypeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIBasicTypeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[910]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DIBasicTypeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DIBasicTypeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DIBasicTypeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DIBasicTypeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DIBasicTypeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DICompileUnitAttr.cpp b/bindings/Python/Generated/IR/LLVM/DICompileUnitAttr.cpp
deleted file mode 100644
index fe2a9778d..000000000
--- a/bindings/Python/Generated/IR/LLVM/DICompileUnitAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DICompileUnitAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[911]) || tp >= &(gTypes[912])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DICompileUnitAttr::static_kind():
-      tp = &(gTypes[911]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DICompileUnitAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source_language",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source_language());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompileUnitAttr::source_language"),
-    nullptr,
-  },
-  {
-    "is_optimized",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_optimized());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompileUnitAttr::is_optimized"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompileUnitAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompileUnitAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[911]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DICompileUnitAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DICompileUnitAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DICompileUnitAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DICompileUnitAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DICompileUnitAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DICompositeTypeAttr.cpp b/bindings/Python/Generated/IR/LLVM/DICompositeTypeAttr.cpp
deleted file mode 100644
index 3a4d259c9..000000000
--- a/bindings/Python/Generated/IR/LLVM/DICompositeTypeAttr.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DICompositeTypeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[912]) || tp >= &(gTypes[913])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DICompositeTypeAttr::static_kind():
-      tp = &(gTypes[912]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DICompositeTypeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "tag",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->tag());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompositeTypeAttr::tag"),
-    nullptr,
-  },
-  {
-    "line",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->line());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompositeTypeAttr::line"),
-    nullptr,
-  },
-  {
-    "size_in_bits",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size_in_bits());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompositeTypeAttr::size_in_bits"),
-    nullptr,
-  },
-  {
-    "align_in_bits",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->align_in_bits());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompositeTypeAttr::align_in_bits"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompositeTypeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DICompositeTypeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[912]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DICompositeTypeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DICompositeTypeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DICompositeTypeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DICompositeTypeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DICompositeTypeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DIDerivedTypeAttr.cpp b/bindings/Python/Generated/IR/LLVM/DIDerivedTypeAttr.cpp
deleted file mode 100644
index f2feca4fb..000000000
--- a/bindings/Python/Generated/IR/LLVM/DIDerivedTypeAttr.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DIDerivedTypeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[913]) || tp >= &(gTypes[914])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DIDerivedTypeAttr::static_kind():
-      tp = &(gTypes[913]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DIDerivedTypeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "tag",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->tag());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIDerivedTypeAttr::tag"),
-    nullptr,
-  },
-  {
-    "size_in_bits",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size_in_bits());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIDerivedTypeAttr::size_in_bits"),
-    nullptr,
-  },
-  {
-    "align_in_bits",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->align_in_bits());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIDerivedTypeAttr::align_in_bits"),
-    nullptr,
-  },
-  {
-    "offset_in_bits",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->offset_in_bits());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIDerivedTypeAttr::offset_in_bits"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIDerivedTypeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIDerivedTypeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[913]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DIDerivedTypeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DIDerivedTypeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DIDerivedTypeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DIDerivedTypeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DIDerivedTypeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DIExpressionAttr.cpp b/bindings/Python/Generated/IR/LLVM/DIExpressionAttr.cpp
deleted file mode 100644
index 9421f7e95..000000000
--- a/bindings/Python/Generated/IR/LLVM/DIExpressionAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DIExpressionAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[908]) || tp >= &(gTypes[909])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DIExpressionAttr::static_kind():
-      tp = &(gTypes[908]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DIExpressionAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIExpressionAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIExpressionAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[908]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DIExpressionAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DIExpressionAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DIExpressionAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DIExpressionAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DIExpressionAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DIExpressionElemAttr.cpp b/bindings/Python/Generated/IR/LLVM/DIExpressionElemAttr.cpp
deleted file mode 100644
index 11038c679..000000000
--- a/bindings/Python/Generated/IR/LLVM/DIExpressionElemAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DIExpressionElemAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[907]) || tp >= &(gTypes[908])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DIExpressionElemAttr::static_kind():
-      tp = &(gTypes[907]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DIExpressionElemAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "opcode",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->opcode());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIExpressionElemAttr::opcode"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIExpressionElemAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIExpressionElemAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[907]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DIExpressionElemAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DIExpressionElemAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DIExpressionElemAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DIExpressionElemAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DIExpressionElemAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DIFileAttr.cpp b/bindings/Python/Generated/IR/LLVM/DIFileAttr.cpp
deleted file mode 100644
index ccda4f93e..000000000
--- a/bindings/Python/Generated/IR/LLVM/DIFileAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DIFileAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[914]) || tp >= &(gTypes[915])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DIFileAttr::static_kind():
-      tp = &(gTypes[914]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DIFileAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIFileAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIFileAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[914]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DIFileAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DIFileAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DIFileAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DIFileAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DIFileAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DIGlobalVariableAttr.cpp b/bindings/Python/Generated/IR/LLVM/DIGlobalVariableAttr.cpp
deleted file mode 100644
index d97a576be..000000000
--- a/bindings/Python/Generated/IR/LLVM/DIGlobalVariableAttr.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DIGlobalVariableAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[916]) || tp >= &(gTypes[917])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DIGlobalVariableAttr::static_kind():
-      tp = &(gTypes[916]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DIGlobalVariableAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "line",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->line());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIGlobalVariableAttr::line"),
-    nullptr,
-  },
-  {
-    "is_local_to_unit",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_local_to_unit());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIGlobalVariableAttr::is_local_to_unit"),
-    nullptr,
-  },
-  {
-    "is_defined",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_defined());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIGlobalVariableAttr::is_defined"),
-    nullptr,
-  },
-  {
-    "align_in_bits",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->align_in_bits());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIGlobalVariableAttr::align_in_bits"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIGlobalVariableAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIGlobalVariableAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[916]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DIGlobalVariableAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DIGlobalVariableAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DIGlobalVariableAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DIGlobalVariableAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DIGlobalVariableAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DIGlobalVariableExpressionAttr.cpp b/bindings/Python/Generated/IR/LLVM/DIGlobalVariableExpressionAttr.cpp
deleted file mode 100644
index eb7b66e9d..000000000
--- a/bindings/Python/Generated/IR/LLVM/DIGlobalVariableExpressionAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DIGlobalVariableExpressionAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[915]) || tp >= &(gTypes[916])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DIGlobalVariableExpressionAttr::static_kind():
-      tp = &(gTypes[915]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DIGlobalVariableExpressionAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIGlobalVariableExpressionAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIGlobalVariableExpressionAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[915]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DIGlobalVariableExpressionAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DIGlobalVariableExpressionAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DIGlobalVariableExpressionAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DIGlobalVariableExpressionAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DIGlobalVariableExpressionAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DILabelAttr.cpp b/bindings/Python/Generated/IR/LLVM/DILabelAttr.cpp
deleted file mode 100644
index 87b35d02c..000000000
--- a/bindings/Python/Generated/IR/LLVM/DILabelAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DILabelAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[925]) || tp >= &(gTypes[926])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DILabelAttr::static_kind():
-      tp = &(gTypes[925]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DILabelAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "line",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->line());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILabelAttr::line"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILabelAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILabelAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[925]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DILabelAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DILabelAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DILabelAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DILabelAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DILabelAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DILexicalBlockAttr.cpp b/bindings/Python/Generated/IR/LLVM/DILexicalBlockAttr.cpp
deleted file mode 100644
index c426fa653..000000000
--- a/bindings/Python/Generated/IR/LLVM/DILexicalBlockAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DILexicalBlockAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[917]) || tp >= &(gTypes[918])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DILexicalBlockAttr::static_kind():
-      tp = &(gTypes[917]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DILexicalBlockAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "line",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->line());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILexicalBlockAttr::line"),
-    nullptr,
-  },
-  {
-    "column",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->column());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILexicalBlockAttr::column"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILexicalBlockAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILexicalBlockAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[917]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DILexicalBlockAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DILexicalBlockAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DILexicalBlockAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DILexicalBlockAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DILexicalBlockAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DILexicalBlockFileAttr.cpp b/bindings/Python/Generated/IR/LLVM/DILexicalBlockFileAttr.cpp
deleted file mode 100644
index 4a3b8b6d8..000000000
--- a/bindings/Python/Generated/IR/LLVM/DILexicalBlockFileAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DILexicalBlockFileAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[918]) || tp >= &(gTypes[919])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DILexicalBlockFileAttr::static_kind():
-      tp = &(gTypes[918]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DILexicalBlockFileAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "discriminator",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->discriminator());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILexicalBlockFileAttr::discriminator"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILexicalBlockFileAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILexicalBlockFileAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[918]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DILexicalBlockFileAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DILexicalBlockFileAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DILexicalBlockFileAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DILexicalBlockFileAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DILexicalBlockFileAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DILocalVariableAttr.cpp b/bindings/Python/Generated/IR/LLVM/DILocalVariableAttr.cpp
deleted file mode 100644
index a8095f9ab..000000000
--- a/bindings/Python/Generated/IR/LLVM/DILocalVariableAttr.cpp
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DILocalVariableAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[919]) || tp >= &(gTypes[920])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DILocalVariableAttr::static_kind():
-      tp = &(gTypes[919]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DILocalVariableAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "line",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->line());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILocalVariableAttr::line"),
-    nullptr,
-  },
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILocalVariableAttr::argument"),
-    nullptr,
-  },
-  {
-    "align_in_bits",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->align_in_bits());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILocalVariableAttr::align_in_bits"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILocalVariableAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DILocalVariableAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[919]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DILocalVariableAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DILocalVariableAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DILocalVariableAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DILocalVariableAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DILocalVariableAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DIModuleAttr.cpp b/bindings/Python/Generated/IR/LLVM/DIModuleAttr.cpp
deleted file mode 100644
index e48ce5e06..000000000
--- a/bindings/Python/Generated/IR/LLVM/DIModuleAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DIModuleAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[921]) || tp >= &(gTypes[922])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DIModuleAttr::static_kind():
-      tp = &(gTypes[921]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DIModuleAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "line",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->line());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIModuleAttr::line"),
-    nullptr,
-  },
-  {
-    "is_decl",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_decl());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIModuleAttr::is_decl"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIModuleAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DIModuleAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[921]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DIModuleAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DIModuleAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DIModuleAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DIModuleAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DIModuleAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DINamespaceAttr.cpp b/bindings/Python/Generated/IR/LLVM/DINamespaceAttr.cpp
deleted file mode 100644
index dcb9604c1..000000000
--- a/bindings/Python/Generated/IR/LLVM/DINamespaceAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DINamespaceAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[922]) || tp >= &(gTypes[923])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DINamespaceAttr::static_kind():
-      tp = &(gTypes[922]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DINamespaceAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "export_symbols",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->export_symbols());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DINamespaceAttr::export_symbols"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DINamespaceAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DINamespaceAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[922]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DINamespaceAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DINamespaceAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DINamespaceAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DINamespaceAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DINamespaceAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DINullTypeAttr.cpp b/bindings/Python/Generated/IR/LLVM/DINullTypeAttr.cpp
deleted file mode 100644
index 79fdd805b..000000000
--- a/bindings/Python/Generated/IR/LLVM/DINullTypeAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DINullTypeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[909]) || tp >= &(gTypes[910])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DINullTypeAttr::static_kind():
-      tp = &(gTypes[909]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DINullTypeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DINullTypeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DINullTypeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[909]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DINullTypeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DINullTypeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DINullTypeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DINullTypeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DINullTypeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DISubprogramAttr.cpp b/bindings/Python/Generated/IR/LLVM/DISubprogramAttr.cpp
deleted file mode 100644
index 24f10e7b8..000000000
--- a/bindings/Python/Generated/IR/LLVM/DISubprogramAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DISubprogramAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[920]) || tp >= &(gTypes[921])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DISubprogramAttr::static_kind():
-      tp = &(gTypes[920]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DISubprogramAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "line",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->line());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DISubprogramAttr::line"),
-    nullptr,
-  },
-  {
-    "scope_line",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->scope_line());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DISubprogramAttr::scope_line"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DISubprogramAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DISubprogramAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[920]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DISubprogramAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DISubprogramAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DISubprogramAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DISubprogramAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DISubprogramAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DISubrangeAttr.cpp b/bindings/Python/Generated/IR/LLVM/DISubrangeAttr.cpp
deleted file mode 100644
index 8387eeadb..000000000
--- a/bindings/Python/Generated/IR/LLVM/DISubrangeAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DISubrangeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[923]) || tp >= &(gTypes[924])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DISubrangeAttr::static_kind():
-      tp = &(gTypes[923]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DISubrangeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DISubrangeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DISubrangeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[923]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DISubrangeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DISubrangeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DISubrangeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DISubrangeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DISubrangeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DISubroutineTypeAttr.cpp b/bindings/Python/Generated/IR/LLVM/DISubroutineTypeAttr.cpp
deleted file mode 100644
index 11b2113cf..000000000
--- a/bindings/Python/Generated/IR/LLVM/DISubroutineTypeAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DISubroutineTypeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[924]) || tp >= &(gTypes[925])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DISubroutineTypeAttr::static_kind():
-      tp = &(gTypes[924]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DISubroutineTypeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "calling_convention",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->calling_convention());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DISubroutineTypeAttr::calling_convention"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DISubroutineTypeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DISubroutineTypeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[924]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DISubroutineTypeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DISubroutineTypeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DISubroutineTypeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DISubroutineTypeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DISubroutineTypeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DbgDeclareOp.cpp b/bindings/Python/Generated/IR/LLVM/DbgDeclareOp.cpp
deleted file mode 100644
index 9bec65463..000000000
--- a/bindings/Python/Generated/IR/LLVM/DbgDeclareOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DbgDeclareOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1095]) || tp >= &(gTypes[1096])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DbgDeclareOp::static_kind():
-      tp = &(gTypes[1095]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DbgDeclareOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgDeclareOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgDeclareOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgDeclareOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1095]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DbgDeclareOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DbgDeclareOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DbgDeclareOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DbgDeclareOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DbgDeclareOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DbgLabelOp.cpp b/bindings/Python/Generated/IR/LLVM/DbgLabelOp.cpp
deleted file mode 100644
index 1302c5295..000000000
--- a/bindings/Python/Generated/IR/LLVM/DbgLabelOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DbgLabelOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1096]) || tp >= &(gTypes[1097])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DbgLabelOp::static_kind():
-      tp = &(gTypes[1096]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DbgLabelOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgLabelOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgLabelOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgLabelOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1096]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DbgLabelOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DbgLabelOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DbgLabelOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DbgLabelOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DbgLabelOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DbgValueOp.cpp b/bindings/Python/Generated/IR/LLVM/DbgValueOp.cpp
deleted file mode 100644
index 4f2011fed..000000000
--- a/bindings/Python/Generated/IR/LLVM/DbgValueOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DbgValueOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1097]) || tp >= &(gTypes[1098])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DbgValueOp::static_kind():
-      tp = &(gTypes[1097]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DbgValueOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgValueOp::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgValueOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgValueOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DbgValueOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1097]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DbgValueOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DbgValueOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DbgValueOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DbgValueOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DbgValueOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/DebugTrapOp.cpp b/bindings/Python/Generated/IR/LLVM/DebugTrapOp.cpp
deleted file mode 100644
index 319bc1ec6..000000000
--- a/bindings/Python/Generated/IR/LLVM/DebugTrapOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::DebugTrapOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1098]) || tp >= &(gTypes[1099])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::DebugTrapOp::static_kind():
-      tp = &(gTypes[1098]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DebugTrapOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DebugTrapOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DebugTrapOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::DebugTrapOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1098]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.DebugTrapOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::DebugTrapOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DebugTrapOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DebugTrapOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DebugTrapOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/EhTypeidForOp.cpp b/bindings/Python/Generated/IR/LLVM/EhTypeidForOp.cpp
deleted file mode 100644
index e06ad1310..000000000
--- a/bindings/Python/Generated/IR/LLVM/EhTypeidForOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::EhTypeidForOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1099]) || tp >= &(gTypes[1100])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::EhTypeidForOp::static_kind():
-      tp = &(gTypes[1099]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "EhTypeidForOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::EhTypeidForOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::EhTypeidForOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::EhTypeidForOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::EhTypeidForOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1099]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.EhTypeidForOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::EhTypeidForOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'EhTypeidForOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'EhTypeidForOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'EhTypeidForOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/Exp2Op.cpp b/bindings/Python/Generated/IR/LLVM/Exp2Op.cpp
deleted file mode 100644
index 519b1999f..000000000
--- a/bindings/Python/Generated/IR/LLVM/Exp2Op.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::Exp2Op;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1100]) || tp >= &(gTypes[1101])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::Exp2Op::static_kind():
-      tp = &(gTypes[1100]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Exp2Op", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Exp2Op::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Exp2Op::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Exp2Op::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Exp2Op::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Exp2Op::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1100]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.Exp2Op";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::Exp2Op");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Exp2Op.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Exp2Op.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Exp2Op' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ExpOp.cpp b/bindings/Python/Generated/IR/LLVM/ExpOp.cpp
deleted file mode 100644
index 673e917ac..000000000
--- a/bindings/Python/Generated/IR/LLVM/ExpOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ExpOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1101]) || tp >= &(gTypes[1102])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ExpOp::static_kind():
-      tp = &(gTypes[1101]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExpOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1101]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ExpOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ExpOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExpOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExpOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExpOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ExpectOp.cpp b/bindings/Python/Generated/IR/LLVM/ExpectOp.cpp
deleted file mode 100644
index 51a609f58..000000000
--- a/bindings/Python/Generated/IR/LLVM/ExpectOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ExpectOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1102]) || tp >= &(gTypes[1103])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ExpectOp::static_kind():
-      tp = &(gTypes[1102]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExpectOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpectOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpectOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpectOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpectOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1102]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ExpectOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ExpectOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExpectOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExpectOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExpectOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ExpectWithProbabilityOp.cpp b/bindings/Python/Generated/IR/LLVM/ExpectWithProbabilityOp.cpp
deleted file mode 100644
index 9d0e0e2f2..000000000
--- a/bindings/Python/Generated/IR/LLVM/ExpectWithProbabilityOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ExpectWithProbabilityOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1103]) || tp >= &(gTypes[1104])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ExpectWithProbabilityOp::static_kind():
-      tp = &(gTypes[1103]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExpectWithProbabilityOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpectWithProbabilityOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpectWithProbabilityOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpectWithProbabilityOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExpectWithProbabilityOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1103]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ExpectWithProbabilityOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ExpectWithProbabilityOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExpectWithProbabilityOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExpectWithProbabilityOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExpectWithProbabilityOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ExtractElementOp.cpp b/bindings/Python/Generated/IR/LLVM/ExtractElementOp.cpp
deleted file mode 100644
index f54b40923..000000000
--- a/bindings/Python/Generated/IR/LLVM/ExtractElementOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ExtractElementOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1019]) || tp >= &(gTypes[1020])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ExtractElementOp::static_kind():
-      tp = &(gTypes[1019]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExtractElementOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "vector",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->vector());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractElementOp::vector"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractElementOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractElementOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractElementOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractElementOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1019]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ExtractElementOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ExtractElementOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExtractElementOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExtractElementOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExtractElementOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ExtractValueOp.cpp b/bindings/Python/Generated/IR/LLVM/ExtractValueOp.cpp
deleted file mode 100644
index 219edd9b0..000000000
--- a/bindings/Python/Generated/IR/LLVM/ExtractValueOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ExtractValueOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1020]) || tp >= &(gTypes[1021])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ExtractValueOp::static_kind():
-      tp = &(gTypes[1020]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExtractValueOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "container",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->container());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractValueOp::container"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractValueOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractValueOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractValueOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ExtractValueOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1020]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ExtractValueOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ExtractValueOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExtractValueOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExtractValueOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExtractValueOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FAbsOp.cpp b/bindings/Python/Generated/IR/LLVM/FAbsOp.cpp
deleted file mode 100644
index 6aeb9a0ec..000000000
--- a/bindings/Python/Generated/IR/LLVM/FAbsOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FAbsOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1104]) || tp >= &(gTypes[1105])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FAbsOp::static_kind():
-      tp = &(gTypes[1104]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FAbsOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAbsOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAbsOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAbsOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAbsOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAbsOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1104]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FAbsOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FAbsOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FAbsOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FAbsOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FAbsOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FAddOp.cpp b/bindings/Python/Generated/IR/LLVM/FAddOp.cpp
deleted file mode 100644
index e8a70fc01..000000000
--- a/bindings/Python/Generated/IR/LLVM/FAddOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FAddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1021]) || tp >= &(gTypes[1022])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FAddOp::static_kind():
-      tp = &(gTypes[1021]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FAddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAddOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAddOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FAddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1021]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FAddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FAddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FAddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FAddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FAddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FCeilOp.cpp b/bindings/Python/Generated/IR/LLVM/FCeilOp.cpp
deleted file mode 100644
index b475df023..000000000
--- a/bindings/Python/Generated/IR/LLVM/FCeilOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FCeilOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1105]) || tp >= &(gTypes[1106])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FCeilOp::static_kind():
-      tp = &(gTypes[1105]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FCeilOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCeilOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCeilOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCeilOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCeilOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCeilOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1105]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FCeilOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FCeilOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FCeilOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FCeilOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FCeilOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FCmpOp.cpp b/bindings/Python/Generated/IR/LLVM/FCmpOp.cpp
deleted file mode 100644
index c46d06c22..000000000
--- a/bindings/Python/Generated/IR/LLVM/FCmpOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FCmpOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1022]) || tp >= &(gTypes[1023])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FCmpOp::static_kind():
-      tp = &(gTypes[1022]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FCmpOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCmpOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCmpOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCmpOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCmpOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCmpOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FCmpOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1022]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FCmpOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FCmpOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FCmpOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FCmpOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FCmpOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FDivOp.cpp b/bindings/Python/Generated/IR/LLVM/FDivOp.cpp
deleted file mode 100644
index a18909f3e..000000000
--- a/bindings/Python/Generated/IR/LLVM/FDivOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FDivOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1023]) || tp >= &(gTypes[1024])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FDivOp::static_kind():
-      tp = &(gTypes[1023]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FDivOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FDivOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FDivOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FDivOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FDivOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FDivOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FDivOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1023]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FDivOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FDivOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FDivOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FDivOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FDivOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FFloorOp.cpp b/bindings/Python/Generated/IR/LLVM/FFloorOp.cpp
deleted file mode 100644
index 79de7f344..000000000
--- a/bindings/Python/Generated/IR/LLVM/FFloorOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FFloorOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1106]) || tp >= &(gTypes[1107])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FFloorOp::static_kind():
-      tp = &(gTypes[1106]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FFloorOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FFloorOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FFloorOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FFloorOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FFloorOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FFloorOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1106]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FFloorOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FFloorOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FFloorOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FFloorOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FFloorOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FMAOp.cpp b/bindings/Python/Generated/IR/LLVM/FMAOp.cpp
deleted file mode 100644
index f24989b71..000000000
--- a/bindings/Python/Generated/IR/LLVM/FMAOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FMAOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1107]) || tp >= &(gTypes[1108])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FMAOp::static_kind():
-      tp = &(gTypes[1107]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FMAOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMAOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMAOp::b"),
-    nullptr,
-  },
-  {
-    "c",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->c());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMAOp::c"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMAOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMAOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMAOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMAOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1107]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FMAOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FMAOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FMAOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FMAOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FMAOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FMulAddOp.cpp b/bindings/Python/Generated/IR/LLVM/FMulAddOp.cpp
deleted file mode 100644
index 932401a63..000000000
--- a/bindings/Python/Generated/IR/LLVM/FMulAddOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FMulAddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1108]) || tp >= &(gTypes[1109])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FMulAddOp::static_kind():
-      tp = &(gTypes[1108]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FMulAddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulAddOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulAddOp::b"),
-    nullptr,
-  },
-  {
-    "c",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->c());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulAddOp::c"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulAddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulAddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulAddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulAddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1108]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FMulAddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FMulAddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FMulAddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FMulAddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FMulAddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FMulOp.cpp b/bindings/Python/Generated/IR/LLVM/FMulOp.cpp
deleted file mode 100644
index d0b787fbb..000000000
--- a/bindings/Python/Generated/IR/LLVM/FMulOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FMulOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1024]) || tp >= &(gTypes[1025])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FMulOp::static_kind():
-      tp = &(gTypes[1024]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FMulOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FMulOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1024]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FMulOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FMulOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FMulOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FMulOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FMulOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FNegOp.cpp b/bindings/Python/Generated/IR/LLVM/FNegOp.cpp
deleted file mode 100644
index 466f7adc8..000000000
--- a/bindings/Python/Generated/IR/LLVM/FNegOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FNegOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1025]) || tp >= &(gTypes[1026])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FNegOp::static_kind():
-      tp = &(gTypes[1025]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FNegOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "operand",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->operand());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FNegOp::operand"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FNegOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FNegOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FNegOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FNegOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1025]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FNegOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FNegOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FNegOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FNegOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FNegOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FPExtOp.cpp b/bindings/Python/Generated/IR/LLVM/FPExtOp.cpp
deleted file mode 100644
index a467bd5c5..000000000
--- a/bindings/Python/Generated/IR/LLVM/FPExtOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FPExtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1026]) || tp >= &(gTypes[1027])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FPExtOp::static_kind():
-      tp = &(gTypes[1026]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FPExtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPExtOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPExtOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPExtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPExtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPExtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1026]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FPExtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FPExtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FPExtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FPExtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FPExtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FPToSIOp.cpp b/bindings/Python/Generated/IR/LLVM/FPToSIOp.cpp
deleted file mode 100644
index 3989ba9ad..000000000
--- a/bindings/Python/Generated/IR/LLVM/FPToSIOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FPToSIOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1027]) || tp >= &(gTypes[1028])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FPToSIOp::static_kind():
-      tp = &(gTypes[1027]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FPToSIOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToSIOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToSIOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToSIOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToSIOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToSIOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1027]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FPToSIOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FPToSIOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FPToSIOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FPToSIOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FPToSIOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FPToUIOp.cpp b/bindings/Python/Generated/IR/LLVM/FPToUIOp.cpp
deleted file mode 100644
index 053b30ce4..000000000
--- a/bindings/Python/Generated/IR/LLVM/FPToUIOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FPToUIOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1028]) || tp >= &(gTypes[1029])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FPToUIOp::static_kind():
-      tp = &(gTypes[1028]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FPToUIOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToUIOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToUIOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToUIOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToUIOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPToUIOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1028]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FPToUIOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FPToUIOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FPToUIOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FPToUIOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FPToUIOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FPTruncOp.cpp b/bindings/Python/Generated/IR/LLVM/FPTruncOp.cpp
deleted file mode 100644
index 2fd8be18d..000000000
--- a/bindings/Python/Generated/IR/LLVM/FPTruncOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FPTruncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1029]) || tp >= &(gTypes[1030])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FPTruncOp::static_kind():
-      tp = &(gTypes[1029]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FPTruncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPTruncOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPTruncOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPTruncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPTruncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPTruncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1029]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FPTruncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FPTruncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FPTruncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FPTruncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FPTruncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FPowOp.cpp b/bindings/Python/Generated/IR/LLVM/FPowOp.cpp
deleted file mode 100644
index 01cae0b0f..000000000
--- a/bindings/Python/Generated/IR/LLVM/FPowOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FPowOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1143]) || tp >= &(gTypes[1144])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FPowOp::static_kind():
-      tp = &(gTypes[1143]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FPowOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPowOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPowOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPowOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPowOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPowOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FPowOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1143]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FPowOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FPowOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FPowOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FPowOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FPowOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FRemOp.cpp b/bindings/Python/Generated/IR/LLVM/FRemOp.cpp
deleted file mode 100644
index 75809e487..000000000
--- a/bindings/Python/Generated/IR/LLVM/FRemOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FRemOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1030]) || tp >= &(gTypes[1031])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FRemOp::static_kind():
-      tp = &(gTypes[1030]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FRemOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FRemOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FRemOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FRemOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FRemOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FRemOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FRemOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1030]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FRemOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FRemOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FRemOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FRemOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FRemOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FShlOp.cpp b/bindings/Python/Generated/IR/LLVM/FShlOp.cpp
deleted file mode 100644
index 7c9d7c797..000000000
--- a/bindings/Python/Generated/IR/LLVM/FShlOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FShlOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1110]) || tp >= &(gTypes[1111])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FShlOp::static_kind():
-      tp = &(gTypes[1110]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FShlOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShlOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShlOp::b"),
-    nullptr,
-  },
-  {
-    "c",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->c());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShlOp::c"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShlOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShlOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShlOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShlOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1110]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FShlOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FShlOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FShlOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FShlOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FShlOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FShrOp.cpp b/bindings/Python/Generated/IR/LLVM/FShrOp.cpp
deleted file mode 100644
index 3358e757b..000000000
--- a/bindings/Python/Generated/IR/LLVM/FShrOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FShrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1111]) || tp >= &(gTypes[1112])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FShrOp::static_kind():
-      tp = &(gTypes[1111]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FShrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShrOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShrOp::b"),
-    nullptr,
-  },
-  {
-    "c",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->c());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShrOp::c"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FShrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1111]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FShrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FShrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FShrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FShrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FShrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FSubOp.cpp b/bindings/Python/Generated/IR/LLVM/FSubOp.cpp
deleted file mode 100644
index 8420eb2f3..000000000
--- a/bindings/Python/Generated/IR/LLVM/FSubOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FSubOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1031]) || tp >= &(gTypes[1032])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FSubOp::static_kind():
-      tp = &(gTypes[1031]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FSubOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FSubOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FSubOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FSubOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FSubOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FSubOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FSubOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1031]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FSubOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FSubOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FSubOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FSubOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FSubOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FTruncOp.cpp b/bindings/Python/Generated/IR/LLVM/FTruncOp.cpp
deleted file mode 100644
index 68627ef77..000000000
--- a/bindings/Python/Generated/IR/LLVM/FTruncOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FTruncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1109]) || tp >= &(gTypes[1110])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FTruncOp::static_kind():
-      tp = &(gTypes[1109]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FTruncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FTruncOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FTruncOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FTruncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FTruncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FTruncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1109]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FTruncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FTruncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FTruncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FTruncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FTruncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FastmathFlagsAttr.cpp b/bindings/Python/Generated/IR/LLVM/FastmathFlagsAttr.cpp
deleted file mode 100644
index 7ea6748f2..000000000
--- a/bindings/Python/Generated/IR/LLVM/FastmathFlagsAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FastmathFlagsAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[937]) || tp >= &(gTypes[938])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FastmathFlagsAttr::static_kind():
-      tp = &(gTypes[937]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FastmathFlagsAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FastmathFlagsAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FastmathFlagsAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[937]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FastmathFlagsAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FastmathFlagsAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FastmathFlagsAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FastmathFlagsAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FastmathFlagsAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FenceOp.cpp b/bindings/Python/Generated/IR/LLVM/FenceOp.cpp
deleted file mode 100644
index 0b2d44383..000000000
--- a/bindings/Python/Generated/IR/LLVM/FenceOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FenceOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1032]) || tp >= &(gTypes[1033])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FenceOp::static_kind():
-      tp = &(gTypes[1032]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FenceOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "syncscope",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->syncscope());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FenceOp::syncscope"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FenceOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FenceOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FenceOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1032]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FenceOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FenceOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FenceOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FenceOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FenceOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FixedVectorType.cpp b/bindings/Python/Generated/IR/LLVM/FixedVectorType.cpp
deleted file mode 100644
index d20262644..000000000
--- a/bindings/Python/Generated/IR/LLVM/FixedVectorType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FixedVectorType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1493]) || tp >= &(gTypes[1494])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FixedVectorType::static_kind():
-      tp = &(gTypes[1493]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FixedVectorType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "num_elements",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_elements());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FixedVectorType::num_elements"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FixedVectorType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FixedVectorType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1493]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FixedVectorType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FixedVectorType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1489].tp_hash;
-  tp->tp_richcompare = gTypes[1489].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1489]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FixedVectorType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FixedVectorType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FixedVectorType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FramePointerKindAttr.cpp b/bindings/Python/Generated/IR/LLVM/FramePointerKindAttr.cpp
deleted file mode 100644
index 779383467..000000000
--- a/bindings/Python/Generated/IR/LLVM/FramePointerKindAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FramePointerKindAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[896]) || tp >= &(gTypes[897])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FramePointerKindAttr::static_kind():
-      tp = &(gTypes[896]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FramePointerKindAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FramePointerKindAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FramePointerKindAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[896]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FramePointerKindAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FramePointerKindAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FramePointerKindAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FramePointerKindAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FramePointerKindAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FreezeOp.cpp b/bindings/Python/Generated/IR/LLVM/FreezeOp.cpp
deleted file mode 100644
index 52128f00b..000000000
--- a/bindings/Python/Generated/IR/LLVM/FreezeOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FreezeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1033]) || tp >= &(gTypes[1034])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FreezeOp::static_kind():
-      tp = &(gTypes[1033]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FreezeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FreezeOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FreezeOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FreezeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FreezeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FreezeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1033]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FreezeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FreezeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FreezeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FreezeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FreezeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FuncOp.cpp b/bindings/Python/Generated/IR/LLVM/FuncOp.cpp
deleted file mode 100644
index d85b8c888..000000000
--- a/bindings/Python/Generated/IR/LLVM/FuncOp.cpp
+++ /dev/null
@@ -1,425 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FuncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1044]) || tp >= &(gTypes[1045])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FuncOp::static_kind():
-      tp = &(gTypes[1044]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FuncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::body"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::name"),
-    nullptr,
-  },
-  {
-    "visibility",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->visibility());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::visibility"),
-    nullptr,
-  },
-  {
-    "dso_local",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->dso_local());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::dso_local"),
-    nullptr,
-  },
-  {
-    "personality",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->personality());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::personality"),
-    nullptr,
-  },
-  {
-    "garbage_collector",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->garbage_collector());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::garbage_collector"),
-    nullptr,
-  },
-  {
-    "function_entry_count",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->function_entry_count());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::function_entry_count"),
-    nullptr,
-  },
-  {
-    "arm_streaming",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->arm_streaming());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::arm_streaming"),
-    nullptr,
-  },
-  {
-    "arm_locally_streaming",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->arm_locally_streaming());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::arm_locally_streaming"),
-    nullptr,
-  },
-  {
-    "arm_streaming_compatible",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->arm_streaming_compatible());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::arm_streaming_compatible"),
-    nullptr,
-  },
-  {
-    "arm_new_za",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->arm_new_za());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::arm_new_za"),
-    nullptr,
-  },
-  {
-    "arm_preserves_za",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->arm_preserves_za());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::arm_preserves_za"),
-    nullptr,
-  },
-  {
-    "arm_shared_za",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->arm_shared_za());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::arm_shared_za"),
-    nullptr,
-  },
-  {
-    "section",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->section());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::section"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::alignment"),
-    nullptr,
-  },
-  {
-    "target_cpu",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->target_cpu());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::target_cpu"),
-    nullptr,
-  },
-  {
-    "is_var_arg",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_var_arg());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::is_var_arg"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FuncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1044]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FuncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FuncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FuncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FuncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FuncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/FunctionType.cpp b/bindings/Python/Generated/IR/LLVM/FunctionType.cpp
deleted file mode 100644
index 0ef432599..000000000
--- a/bindings/Python/Generated/IR/LLVM/FunctionType.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::FunctionType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1491]) || tp >= &(gTypes[1492])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::FunctionType::static_kind():
-      tp = &(gTypes[1491]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FunctionType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_var_arg",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_var_arg());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FunctionType::is_var_arg"),
-    nullptr,
-  },
-  {
-    "num_params",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_params());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FunctionType::num_params"),
-    nullptr,
-  },
-  {
-    "params",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::params);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FunctionType::params"),
-    nullptr,
-  },
-  {
-    "var_arg",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->var_arg());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FunctionType::var_arg"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FunctionType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::FunctionType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1491]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.FunctionType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::FunctionType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1489].tp_hash;
-  tp->tp_richcompare = gTypes[1489].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1489]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FunctionType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FunctionType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FunctionType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/GetActiveLaneMaskOp.cpp b/bindings/Python/Generated/IR/LLVM/GetActiveLaneMaskOp.cpp
deleted file mode 100644
index 26366501a..000000000
--- a/bindings/Python/Generated/IR/LLVM/GetActiveLaneMaskOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::GetActiveLaneMaskOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1112]) || tp >= &(gTypes[1113])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::GetActiveLaneMaskOp::static_kind():
-      tp = &(gTypes[1112]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GetActiveLaneMaskOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetActiveLaneMaskOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetActiveLaneMaskOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetActiveLaneMaskOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetActiveLaneMaskOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1112]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.GetActiveLaneMaskOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::GetActiveLaneMaskOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GetActiveLaneMaskOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GetActiveLaneMaskOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GetActiveLaneMaskOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/GetElementPtrOp.cpp b/bindings/Python/Generated/IR/LLVM/GetElementPtrOp.cpp
deleted file mode 100644
index c1dd5abab..000000000
--- a/bindings/Python/Generated/IR/LLVM/GetElementPtrOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::GetElementPtrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1034]) || tp >= &(gTypes[1035])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::GetElementPtrOp::static_kind():
-      tp = &(gTypes[1034]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GetElementPtrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "base",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->base());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetElementPtrOp::base"),
-    nullptr,
-  },
-  {
-    "dynamic_indices",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::dynamic_indices);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetElementPtrOp::dynamic_indices"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetElementPtrOp::result"),
-    nullptr,
-  },
-  {
-    "elem_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->elem_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetElementPtrOp::elem_type"),
-    nullptr,
-  },
-  {
-    "inbounds",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->inbounds());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetElementPtrOp::inbounds"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetElementPtrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetElementPtrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GetElementPtrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1034]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.GetElementPtrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::GetElementPtrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GetElementPtrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GetElementPtrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GetElementPtrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/GlobalCtorsOp.cpp b/bindings/Python/Generated/IR/LLVM/GlobalCtorsOp.cpp
deleted file mode 100644
index ab9bb6443..000000000
--- a/bindings/Python/Generated/IR/LLVM/GlobalCtorsOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::GlobalCtorsOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1035]) || tp >= &(gTypes[1036])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::GlobalCtorsOp::static_kind():
-      tp = &(gTypes[1035]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GlobalCtorsOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalCtorsOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalCtorsOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalCtorsOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1035]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.GlobalCtorsOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::GlobalCtorsOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GlobalCtorsOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GlobalCtorsOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GlobalCtorsOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/GlobalDtorsOp.cpp b/bindings/Python/Generated/IR/LLVM/GlobalDtorsOp.cpp
deleted file mode 100644
index c385ce7b8..000000000
--- a/bindings/Python/Generated/IR/LLVM/GlobalDtorsOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::GlobalDtorsOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1036]) || tp >= &(gTypes[1037])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::GlobalDtorsOp::static_kind():
-      tp = &(gTypes[1036]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GlobalDtorsOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalDtorsOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalDtorsOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalDtorsOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1036]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.GlobalDtorsOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::GlobalDtorsOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GlobalDtorsOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GlobalDtorsOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GlobalDtorsOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/GlobalOp.cpp b/bindings/Python/Generated/IR/LLVM/GlobalOp.cpp
deleted file mode 100644
index cad2515d9..000000000
--- a/bindings/Python/Generated/IR/LLVM/GlobalOp.cpp
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::GlobalOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1037]) || tp >= &(gTypes[1038])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::GlobalOp::static_kind():
-      tp = &(gTypes[1037]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GlobalOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "initializer",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->initializer());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::initializer"),
-    nullptr,
-  },
-  {
-    "global_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->global_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::global_type"),
-    nullptr,
-  },
-  {
-    "constant",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->constant());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::constant"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::name"),
-    nullptr,
-  },
-  {
-    "dso_local",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->dso_local());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::dso_local"),
-    nullptr,
-  },
-  {
-    "thread_local__",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->thread_local__());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::thread_local__"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::alignment"),
-    nullptr,
-  },
-  {
-    "addr_space",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->addr_space());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::addr_space"),
-    nullptr,
-  },
-  {
-    "section",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->section());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::section"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::GlobalOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1037]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.GlobalOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::GlobalOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GlobalOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GlobalOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GlobalOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ICmpOp.cpp b/bindings/Python/Generated/IR/LLVM/ICmpOp.cpp
deleted file mode 100644
index 16ca0b2bb..000000000
--- a/bindings/Python/Generated/IR/LLVM/ICmpOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ICmpOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1038]) || tp >= &(gTypes[1039])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ICmpOp::static_kind():
-      tp = &(gTypes[1038]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ICmpOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ICmpOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ICmpOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ICmpOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ICmpOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ICmpOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ICmpOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1038]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ICmpOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ICmpOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ICmpOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ICmpOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ICmpOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/InlineAsmOp.cpp b/bindings/Python/Generated/IR/LLVM/InlineAsmOp.cpp
deleted file mode 100644
index bf44c88f2..000000000
--- a/bindings/Python/Generated/IR/LLVM/InlineAsmOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::InlineAsmOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1039]) || tp >= &(gTypes[1040])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::InlineAsmOp::static_kind():
-      tp = &(gTypes[1039]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InlineAsmOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InlineAsmOp::operands"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InlineAsmOp::result"),
-    nullptr,
-  },
-  {
-    "assembly",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->assembly());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InlineAsmOp::assembly"),
-    nullptr,
-  },
-  {
-    "constraints",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->constraints());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InlineAsmOp::constraints"),
-    nullptr,
-  },
-  {
-    "has_side_effects",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->has_side_effects());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InlineAsmOp::has_side_effects"),
-    nullptr,
-  },
-  {
-    "is_align_stack",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_align_stack());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InlineAsmOp::is_align_stack"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InlineAsmOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InlineAsmOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InlineAsmOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1039]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.InlineAsmOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::InlineAsmOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InlineAsmOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InlineAsmOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InlineAsmOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/InsertElementOp.cpp b/bindings/Python/Generated/IR/LLVM/InsertElementOp.cpp
deleted file mode 100644
index 1f2ee83a4..000000000
--- a/bindings/Python/Generated/IR/LLVM/InsertElementOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::InsertElementOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1040]) || tp >= &(gTypes[1041])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::InsertElementOp::static_kind():
-      tp = &(gTypes[1040]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InsertElementOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "vector",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->vector());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertElementOp::vector"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertElementOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertElementOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertElementOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertElementOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertElementOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1040]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.InsertElementOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::InsertElementOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InsertElementOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InsertElementOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InsertElementOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/InsertValueOp.cpp b/bindings/Python/Generated/IR/LLVM/InsertValueOp.cpp
deleted file mode 100644
index da9573a8f..000000000
--- a/bindings/Python/Generated/IR/LLVM/InsertValueOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::InsertValueOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1041]) || tp >= &(gTypes[1042])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::InsertValueOp::static_kind():
-      tp = &(gTypes[1041]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InsertValueOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "container",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->container());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertValueOp::container"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertValueOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertValueOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertValueOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertValueOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InsertValueOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1041]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.InsertValueOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::InsertValueOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InsertValueOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InsertValueOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InsertValueOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/IntToPtrOp.cpp b/bindings/Python/Generated/IR/LLVM/IntToPtrOp.cpp
deleted file mode 100644
index a24917998..000000000
--- a/bindings/Python/Generated/IR/LLVM/IntToPtrOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::IntToPtrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1042]) || tp >= &(gTypes[1043])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::IntToPtrOp::static_kind():
-      tp = &(gTypes[1042]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IntToPtrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IntToPtrOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IntToPtrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IntToPtrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IntToPtrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IntToPtrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1042]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.IntToPtrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::IntToPtrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IntToPtrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IntToPtrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IntToPtrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/IntegerOverflowFlagsAttr.cpp b/bindings/Python/Generated/IR/LLVM/IntegerOverflowFlagsAttr.cpp
deleted file mode 100644
index 2bd90a62e..000000000
--- a/bindings/Python/Generated/IR/LLVM/IntegerOverflowFlagsAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::IntegerOverflowFlagsAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[936]) || tp >= &(gTypes[937])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::IntegerOverflowFlagsAttr::static_kind():
-      tp = &(gTypes[936]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IntegerOverflowFlagsAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IntegerOverflowFlagsAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IntegerOverflowFlagsAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[936]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.IntegerOverflowFlagsAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::IntegerOverflowFlagsAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IntegerOverflowFlagsAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IntegerOverflowFlagsAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IntegerOverflowFlagsAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/InvariantEndOp.cpp b/bindings/Python/Generated/IR/LLVM/InvariantEndOp.cpp
deleted file mode 100644
index 16313d0e9..000000000
--- a/bindings/Python/Generated/IR/LLVM/InvariantEndOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::InvariantEndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1113]) || tp >= &(gTypes[1114])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::InvariantEndOp::static_kind():
-      tp = &(gTypes[1113]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InvariantEndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvariantEndOp::size"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvariantEndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvariantEndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvariantEndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1113]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.InvariantEndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::InvariantEndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InvariantEndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InvariantEndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InvariantEndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/InvariantStartOp.cpp b/bindings/Python/Generated/IR/LLVM/InvariantStartOp.cpp
deleted file mode 100644
index 7612b5f72..000000000
--- a/bindings/Python/Generated/IR/LLVM/InvariantStartOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::InvariantStartOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1114]) || tp >= &(gTypes[1115])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::InvariantStartOp::static_kind():
-      tp = &(gTypes[1114]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InvariantStartOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvariantStartOp::size"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvariantStartOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvariantStartOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvariantStartOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1114]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.InvariantStartOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::InvariantStartOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InvariantStartOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InvariantStartOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InvariantStartOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/InvokeOp.cpp b/bindings/Python/Generated/IR/LLVM/InvokeOp.cpp
deleted file mode 100644
index 4d001933d..000000000
--- a/bindings/Python/Generated/IR/LLVM/InvokeOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::InvokeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1043]) || tp >= &(gTypes[1044])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::InvokeOp::static_kind():
-      tp = &(gTypes[1043]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InvokeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "callee_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::callee_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvokeOp::callee_operands"),
-    nullptr,
-  },
-  {
-    "normal_dest_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::normal_dest_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvokeOp::normal_dest_operands"),
-    nullptr,
-  },
-  {
-    "unwind_dest_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::unwind_dest_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvokeOp::unwind_dest_operands"),
-    nullptr,
-  },
-  {
-    "callee",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->callee());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvokeOp::callee"),
-    nullptr,
-  },
-  {
-    "arg_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arg_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvokeOp::arg_operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvokeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvokeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::InvokeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1043]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.InvokeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::InvokeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InvokeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InvokeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InvokeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/IsConstantOp.cpp b/bindings/Python/Generated/IR/LLVM/IsConstantOp.cpp
deleted file mode 100644
index 4dea4dd8a..000000000
--- a/bindings/Python/Generated/IR/LLVM/IsConstantOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::IsConstantOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1115]) || tp >= &(gTypes[1116])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::IsConstantOp::static_kind():
-      tp = &(gTypes[1115]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IsConstantOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsConstantOp::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsConstantOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsConstantOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsConstantOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1115]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.IsConstantOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::IsConstantOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IsConstantOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IsConstantOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IsConstantOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/IsFPClassOp.cpp b/bindings/Python/Generated/IR/LLVM/IsFPClassOp.cpp
deleted file mode 100644
index 25f2e8769..000000000
--- a/bindings/Python/Generated/IR/LLVM/IsFPClassOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::IsFPClassOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1116]) || tp >= &(gTypes[1117])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::IsFPClassOp::static_kind():
-      tp = &(gTypes[1116]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IsFPClassOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsFPClassOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsFPClassOp::result"),
-    nullptr,
-  },
-  {
-    "bit",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->bit());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsFPClassOp::bit"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsFPClassOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsFPClassOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::IsFPClassOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1116]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.IsFPClassOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::IsFPClassOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IsFPClassOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IsFPClassOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IsFPClassOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LShrOp.cpp b/bindings/Python/Generated/IR/LLVM/LShrOp.cpp
deleted file mode 100644
index 6753096c9..000000000
--- a/bindings/Python/Generated/IR/LLVM/LShrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LShrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1045]) || tp >= &(gTypes[1046])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LShrOp::static_kind():
-      tp = &(gTypes[1045]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LShrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LShrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LShrOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LShrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LShrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LShrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LShrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1045]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LShrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LShrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LShrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LShrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LShrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LandingpadOp.cpp b/bindings/Python/Generated/IR/LLVM/LandingpadOp.cpp
deleted file mode 100644
index a44a28d8b..000000000
--- a/bindings/Python/Generated/IR/LLVM/LandingpadOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LandingpadOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1046]) || tp >= &(gTypes[1047])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LandingpadOp::static_kind():
-      tp = &(gTypes[1046]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LandingpadOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LandingpadOp::result"),
-    nullptr,
-  },
-  {
-    "cleanup",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->cleanup());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LandingpadOp::cleanup"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LandingpadOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LandingpadOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LandingpadOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1046]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LandingpadOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LandingpadOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LandingpadOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LandingpadOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LandingpadOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LifetimeEndOp.cpp b/bindings/Python/Generated/IR/LLVM/LifetimeEndOp.cpp
deleted file mode 100644
index 16324f715..000000000
--- a/bindings/Python/Generated/IR/LLVM/LifetimeEndOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LifetimeEndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1117]) || tp >= &(gTypes[1118])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LifetimeEndOp::static_kind():
-      tp = &(gTypes[1117]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LifetimeEndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LifetimeEndOp::size"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LifetimeEndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LifetimeEndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LifetimeEndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1117]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LifetimeEndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LifetimeEndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LifetimeEndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LifetimeEndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LifetimeEndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LifetimeStartOp.cpp b/bindings/Python/Generated/IR/LLVM/LifetimeStartOp.cpp
deleted file mode 100644
index 7c330ab6e..000000000
--- a/bindings/Python/Generated/IR/LLVM/LifetimeStartOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LifetimeStartOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1118]) || tp >= &(gTypes[1119])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LifetimeStartOp::static_kind():
-      tp = &(gTypes[1118]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LifetimeStartOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LifetimeStartOp::size"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LifetimeStartOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LifetimeStartOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LifetimeStartOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1118]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LifetimeStartOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LifetimeStartOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LifetimeStartOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LifetimeStartOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LifetimeStartOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LinkageAttr.cpp b/bindings/Python/Generated/IR/LLVM/LinkageAttr.cpp
deleted file mode 100644
index f1cc3c9af..000000000
--- a/bindings/Python/Generated/IR/LLVM/LinkageAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LinkageAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[895]) || tp >= &(gTypes[896])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LinkageAttr::static_kind():
-      tp = &(gTypes[895]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LinkageAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LinkageAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LinkageAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[895]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LinkageAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LinkageAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LinkageAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LinkageAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LinkageAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LinkerOptionsOp.cpp b/bindings/Python/Generated/IR/LLVM/LinkerOptionsOp.cpp
deleted file mode 100644
index 7302b9395..000000000
--- a/bindings/Python/Generated/IR/LLVM/LinkerOptionsOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LinkerOptionsOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1047]) || tp >= &(gTypes[1048])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LinkerOptionsOp::static_kind():
-      tp = &(gTypes[1047]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LinkerOptionsOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LinkerOptionsOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LinkerOptionsOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LinkerOptionsOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1047]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LinkerOptionsOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LinkerOptionsOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LinkerOptionsOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LinkerOptionsOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LinkerOptionsOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoadOp.cpp b/bindings/Python/Generated/IR/LLVM/LoadOp.cpp
deleted file mode 100644
index 5179d72f1..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoadOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoadOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1048]) || tp >= &(gTypes[1049])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoadOp::static_kind():
-      tp = &(gTypes[1048]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoadOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoadOp::result"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoadOp::alignment"),
-    nullptr,
-  },
-  {
-    "volatile__",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->volatile__());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoadOp::volatile__"),
-    nullptr,
-  },
-  {
-    "nontemporal",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->nontemporal());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoadOp::nontemporal"),
-    nullptr,
-  },
-  {
-    "invariant",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->invariant());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoadOp::invariant"),
-    nullptr,
-  },
-  {
-    "syncscope",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->syncscope());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoadOp::syncscope"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoadOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoadOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoadOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1048]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoadOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoadOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoadOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoadOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoadOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/Log10Op.cpp b/bindings/Python/Generated/IR/LLVM/Log10Op.cpp
deleted file mode 100644
index 5b251a479..000000000
--- a/bindings/Python/Generated/IR/LLVM/Log10Op.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::Log10Op;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1121]) || tp >= &(gTypes[1122])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::Log10Op::static_kind():
-      tp = &(gTypes[1121]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Log10Op", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log10Op::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log10Op::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log10Op::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log10Op::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log10Op::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1121]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.Log10Op";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::Log10Op");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Log10Op.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Log10Op.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Log10Op' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/Log2Op.cpp b/bindings/Python/Generated/IR/LLVM/Log2Op.cpp
deleted file mode 100644
index a87880b84..000000000
--- a/bindings/Python/Generated/IR/LLVM/Log2Op.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::Log2Op;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1122]) || tp >= &(gTypes[1123])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::Log2Op::static_kind():
-      tp = &(gTypes[1122]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Log2Op", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log2Op::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log2Op::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log2Op::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log2Op::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Log2Op::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1122]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.Log2Op";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::Log2Op");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Log2Op.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Log2Op.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Log2Op' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LogOp.cpp b/bindings/Python/Generated/IR/LLVM/LogOp.cpp
deleted file mode 100644
index 5d93df2da..000000000
--- a/bindings/Python/Generated/IR/LLVM/LogOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LogOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1123]) || tp >= &(gTypes[1124])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LogOp::static_kind():
-      tp = &(gTypes[1123]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LogOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LogOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LogOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LogOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LogOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LogOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1123]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LogOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LogOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LogOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LogOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LogOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopAnnotationAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopAnnotationAttr.cpp
deleted file mode 100644
index f898b842b..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopAnnotationAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopAnnotationAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[906]) || tp >= &(gTypes[907])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopAnnotationAttr::static_kind():
-      tp = &(gTypes[906]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopAnnotationAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopAnnotationAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopAnnotationAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[906]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopAnnotationAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopAnnotationAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopAnnotationAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopAnnotationAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopAnnotationAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopDistributeAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopDistributeAttr.cpp
deleted file mode 100644
index 243e78838..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopDistributeAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopDistributeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[902]) || tp >= &(gTypes[903])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopDistributeAttr::static_kind():
-      tp = &(gTypes[902]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopDistributeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopDistributeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopDistributeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[902]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopDistributeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopDistributeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopDistributeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopDistributeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopDistributeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopInterleaveAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopInterleaveAttr.cpp
deleted file mode 100644
index f0e8a3d27..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopInterleaveAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopInterleaveAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[898]) || tp >= &(gTypes[899])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopInterleaveAttr::static_kind():
-      tp = &(gTypes[898]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopInterleaveAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopInterleaveAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopInterleaveAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[898]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopInterleaveAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopInterleaveAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopInterleaveAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopInterleaveAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopInterleaveAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopLICMAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopLICMAttr.cpp
deleted file mode 100644
index ce58af74e..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopLICMAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopLICMAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[901]) || tp >= &(gTypes[902])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopLICMAttr::static_kind():
-      tp = &(gTypes[901]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopLICMAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopLICMAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopLICMAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[901]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopLICMAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopLICMAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopLICMAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopLICMAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopLICMAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopPeeledAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopPeeledAttr.cpp
deleted file mode 100644
index 7c77a42df..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopPeeledAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopPeeledAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[904]) || tp >= &(gTypes[905])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopPeeledAttr::static_kind():
-      tp = &(gTypes[904]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopPeeledAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopPeeledAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopPeeledAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[904]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopPeeledAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopPeeledAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopPeeledAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopPeeledAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopPeeledAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopPipelineAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopPipelineAttr.cpp
deleted file mode 100644
index 7c43e850a..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopPipelineAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopPipelineAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[903]) || tp >= &(gTypes[904])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopPipelineAttr::static_kind():
-      tp = &(gTypes[903]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopPipelineAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopPipelineAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopPipelineAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[903]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopPipelineAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopPipelineAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopPipelineAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopPipelineAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopPipelineAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopUnrollAndJamAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopUnrollAndJamAttr.cpp
deleted file mode 100644
index 19025cb3a..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopUnrollAndJamAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopUnrollAndJamAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[900]) || tp >= &(gTypes[901])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopUnrollAndJamAttr::static_kind():
-      tp = &(gTypes[900]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopUnrollAndJamAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopUnrollAndJamAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopUnrollAndJamAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[900]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopUnrollAndJamAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopUnrollAndJamAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopUnrollAndJamAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopUnrollAndJamAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopUnrollAndJamAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopUnrollAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopUnrollAttr.cpp
deleted file mode 100644
index 7c2c58598..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopUnrollAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopUnrollAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[899]) || tp >= &(gTypes[900])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopUnrollAttr::static_kind():
-      tp = &(gTypes[899]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopUnrollAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopUnrollAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopUnrollAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[899]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopUnrollAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopUnrollAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopUnrollAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopUnrollAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopUnrollAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopUnswitchAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopUnswitchAttr.cpp
deleted file mode 100644
index 0ee72f839..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopUnswitchAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopUnswitchAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[905]) || tp >= &(gTypes[906])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopUnswitchAttr::static_kind():
-      tp = &(gTypes[905]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopUnswitchAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopUnswitchAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopUnswitchAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[905]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopUnswitchAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopUnswitchAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopUnswitchAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopUnswitchAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopUnswitchAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/LoopVectorizeAttr.cpp b/bindings/Python/Generated/IR/LLVM/LoopVectorizeAttr.cpp
deleted file mode 100644
index 01e43ce2e..000000000
--- a/bindings/Python/Generated/IR/LLVM/LoopVectorizeAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::LoopVectorizeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[897]) || tp >= &(gTypes[898])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::LoopVectorizeAttr::static_kind():
-      tp = &(gTypes[897]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoopVectorizeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopVectorizeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::LoopVectorizeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[897]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.LoopVectorizeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::LoopVectorizeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoopVectorizeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoopVectorizeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoopVectorizeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MaskedCompressStoreOp.cpp b/bindings/Python/Generated/IR/LLVM/MaskedCompressStoreOp.cpp
deleted file mode 100644
index ccf5e2216..000000000
--- a/bindings/Python/Generated/IR/LLVM/MaskedCompressStoreOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MaskedCompressStoreOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1229]) || tp >= &(gTypes[1230])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MaskedCompressStoreOp::static_kind():
-      tp = &(gTypes[1229]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MaskedCompressStoreOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedCompressStoreOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedCompressStoreOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedCompressStoreOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1229]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MaskedCompressStoreOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MaskedCompressStoreOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MaskedCompressStoreOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MaskedCompressStoreOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MaskedCompressStoreOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MaskedExpandLoadOp.cpp b/bindings/Python/Generated/IR/LLVM/MaskedExpandLoadOp.cpp
deleted file mode 100644
index b7d31473b..000000000
--- a/bindings/Python/Generated/IR/LLVM/MaskedExpandLoadOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MaskedExpandLoadOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1230]) || tp >= &(gTypes[1231])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MaskedExpandLoadOp::static_kind():
-      tp = &(gTypes[1230]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MaskedExpandLoadOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedExpandLoadOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedExpandLoadOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedExpandLoadOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedExpandLoadOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1230]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MaskedExpandLoadOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MaskedExpandLoadOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MaskedExpandLoadOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MaskedExpandLoadOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MaskedExpandLoadOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MaskedGatherOp.cpp b/bindings/Python/Generated/IR/LLVM/MaskedGatherOp.cpp
deleted file mode 100644
index 07a0a4de6..000000000
--- a/bindings/Python/Generated/IR/LLVM/MaskedGatherOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MaskedGatherOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1231]) || tp >= &(gTypes[1232])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MaskedGatherOp::static_kind():
-      tp = &(gTypes[1231]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MaskedGatherOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "ptrs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->ptrs());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedGatherOp::ptrs"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedGatherOp::mask"),
-    nullptr,
-  },
-  {
-    "pass_thru",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::pass_thru);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedGatherOp::pass_thru"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedGatherOp::result"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedGatherOp::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedGatherOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedGatherOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedGatherOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1231]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MaskedGatherOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MaskedGatherOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MaskedGatherOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MaskedGatherOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MaskedGatherOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MaskedLoadOp.cpp b/bindings/Python/Generated/IR/LLVM/MaskedLoadOp.cpp
deleted file mode 100644
index a9fcd5ee0..000000000
--- a/bindings/Python/Generated/IR/LLVM/MaskedLoadOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MaskedLoadOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1126]) || tp >= &(gTypes[1127])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MaskedLoadOp::static_kind():
-      tp = &(gTypes[1126]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MaskedLoadOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedLoadOp::mask"),
-    nullptr,
-  },
-  {
-    "pass_thru",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::pass_thru);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedLoadOp::pass_thru"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedLoadOp::result"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedLoadOp::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedLoadOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedLoadOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedLoadOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1126]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MaskedLoadOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MaskedLoadOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MaskedLoadOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MaskedLoadOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MaskedLoadOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MaskedScatterOp.cpp b/bindings/Python/Generated/IR/LLVM/MaskedScatterOp.cpp
deleted file mode 100644
index 14b0b2a0d..000000000
--- a/bindings/Python/Generated/IR/LLVM/MaskedScatterOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MaskedScatterOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1232]) || tp >= &(gTypes[1233])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MaskedScatterOp::static_kind():
-      tp = &(gTypes[1232]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MaskedScatterOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedScatterOp::value"),
-    nullptr,
-  },
-  {
-    "ptrs",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->ptrs());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedScatterOp::ptrs"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedScatterOp::mask"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedScatterOp::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedScatterOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedScatterOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedScatterOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1232]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MaskedScatterOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MaskedScatterOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MaskedScatterOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MaskedScatterOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MaskedScatterOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MaskedStoreOp.cpp b/bindings/Python/Generated/IR/LLVM/MaskedStoreOp.cpp
deleted file mode 100644
index dd9dcbfe8..000000000
--- a/bindings/Python/Generated/IR/LLVM/MaskedStoreOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MaskedStoreOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1127]) || tp >= &(gTypes[1128])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MaskedStoreOp::static_kind():
-      tp = &(gTypes[1127]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MaskedStoreOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedStoreOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedStoreOp::mask"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedStoreOp::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedStoreOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedStoreOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaskedStoreOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1127]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MaskedStoreOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MaskedStoreOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MaskedStoreOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MaskedStoreOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MaskedStoreOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MatrixColumnMajorLoadOp.cpp b/bindings/Python/Generated/IR/LLVM/MatrixColumnMajorLoadOp.cpp
deleted file mode 100644
index 725646558..000000000
--- a/bindings/Python/Generated/IR/LLVM/MatrixColumnMajorLoadOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MatrixColumnMajorLoadOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1128]) || tp >= &(gTypes[1129])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MatrixColumnMajorLoadOp::static_kind():
-      tp = &(gTypes[1128]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MatrixColumnMajorLoadOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorLoadOp::result"),
-    nullptr,
-  },
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorLoadOp::is_volatile"),
-    nullptr,
-  },
-  {
-    "rows",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->rows());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorLoadOp::rows"),
-    nullptr,
-  },
-  {
-    "columns",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->columns());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorLoadOp::columns"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorLoadOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorLoadOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorLoadOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1128]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MatrixColumnMajorLoadOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MatrixColumnMajorLoadOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MatrixColumnMajorLoadOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MatrixColumnMajorLoadOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MatrixColumnMajorLoadOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MatrixColumnMajorStoreOp.cpp b/bindings/Python/Generated/IR/LLVM/MatrixColumnMajorStoreOp.cpp
deleted file mode 100644
index caeed32c7..000000000
--- a/bindings/Python/Generated/IR/LLVM/MatrixColumnMajorStoreOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MatrixColumnMajorStoreOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1129]) || tp >= &(gTypes[1130])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MatrixColumnMajorStoreOp::static_kind():
-      tp = &(gTypes[1129]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MatrixColumnMajorStoreOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "matrix",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->matrix());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorStoreOp::matrix"),
-    nullptr,
-  },
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorStoreOp::is_volatile"),
-    nullptr,
-  },
-  {
-    "rows",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->rows());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorStoreOp::rows"),
-    nullptr,
-  },
-  {
-    "columns",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->columns());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorStoreOp::columns"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorStoreOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorStoreOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixColumnMajorStoreOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1129]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MatrixColumnMajorStoreOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MatrixColumnMajorStoreOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MatrixColumnMajorStoreOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MatrixColumnMajorStoreOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MatrixColumnMajorStoreOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MatrixMultiplyOp.cpp b/bindings/Python/Generated/IR/LLVM/MatrixMultiplyOp.cpp
deleted file mode 100644
index d689397ba..000000000
--- a/bindings/Python/Generated/IR/LLVM/MatrixMultiplyOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MatrixMultiplyOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1130]) || tp >= &(gTypes[1131])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MatrixMultiplyOp::static_kind():
-      tp = &(gTypes[1130]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MatrixMultiplyOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixMultiplyOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixMultiplyOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixMultiplyOp::result"),
-    nullptr,
-  },
-  {
-    "lhs_rows",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->lhs_rows());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixMultiplyOp::lhs_rows"),
-    nullptr,
-  },
-  {
-    "lhs_columns",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->lhs_columns());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixMultiplyOp::lhs_columns"),
-    nullptr,
-  },
-  {
-    "rhs_columns",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->rhs_columns());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixMultiplyOp::rhs_columns"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixMultiplyOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixMultiplyOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixMultiplyOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1130]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MatrixMultiplyOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MatrixMultiplyOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MatrixMultiplyOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MatrixMultiplyOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MatrixMultiplyOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MatrixTransposeOp.cpp b/bindings/Python/Generated/IR/LLVM/MatrixTransposeOp.cpp
deleted file mode 100644
index 02ad05e69..000000000
--- a/bindings/Python/Generated/IR/LLVM/MatrixTransposeOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MatrixTransposeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1131]) || tp >= &(gTypes[1132])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MatrixTransposeOp::static_kind():
-      tp = &(gTypes[1131]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MatrixTransposeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "matrix",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->matrix());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixTransposeOp::matrix"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixTransposeOp::result"),
-    nullptr,
-  },
-  {
-    "rows",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->rows());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixTransposeOp::rows"),
-    nullptr,
-  },
-  {
-    "columns",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->columns());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixTransposeOp::columns"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixTransposeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixTransposeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MatrixTransposeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1131]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MatrixTransposeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MatrixTransposeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MatrixTransposeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MatrixTransposeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MatrixTransposeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MaxNumOp.cpp b/bindings/Python/Generated/IR/LLVM/MaxNumOp.cpp
deleted file mode 100644
index b8732674c..000000000
--- a/bindings/Python/Generated/IR/LLVM/MaxNumOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MaxNumOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1132]) || tp >= &(gTypes[1133])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MaxNumOp::static_kind():
-      tp = &(gTypes[1132]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MaxNumOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaxNumOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaxNumOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaxNumOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaxNumOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaxNumOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaxNumOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1132]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MaxNumOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MaxNumOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MaxNumOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MaxNumOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MaxNumOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MaximumOp.cpp b/bindings/Python/Generated/IR/LLVM/MaximumOp.cpp
deleted file mode 100644
index ec2b0cc66..000000000
--- a/bindings/Python/Generated/IR/LLVM/MaximumOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MaximumOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1133]) || tp >= &(gTypes[1134])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MaximumOp::static_kind():
-      tp = &(gTypes[1133]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MaximumOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaximumOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaximumOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaximumOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaximumOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaximumOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MaximumOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1133]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MaximumOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MaximumOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MaximumOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MaximumOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MaximumOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MemcpyInlineOp.cpp b/bindings/Python/Generated/IR/LLVM/MemcpyInlineOp.cpp
deleted file mode 100644
index 8c942309b..000000000
--- a/bindings/Python/Generated/IR/LLVM/MemcpyInlineOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MemcpyInlineOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1134]) || tp >= &(gTypes[1135])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MemcpyInlineOp::static_kind():
-      tp = &(gTypes[1134]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MemcpyInlineOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemcpyInlineOp::is_volatile"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemcpyInlineOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemcpyInlineOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemcpyInlineOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1134]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MemcpyInlineOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MemcpyInlineOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MemcpyInlineOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MemcpyInlineOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MemcpyInlineOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MemcpyOp.cpp b/bindings/Python/Generated/IR/LLVM/MemcpyOp.cpp
deleted file mode 100644
index 6a0614a7e..000000000
--- a/bindings/Python/Generated/IR/LLVM/MemcpyOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MemcpyOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1135]) || tp >= &(gTypes[1136])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MemcpyOp::static_kind():
-      tp = &(gTypes[1135]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MemcpyOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemcpyOp::is_volatile"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemcpyOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemcpyOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemcpyOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1135]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MemcpyOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MemcpyOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MemcpyOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MemcpyOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MemcpyOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MemmoveOp.cpp b/bindings/Python/Generated/IR/LLVM/MemmoveOp.cpp
deleted file mode 100644
index 3d92001bf..000000000
--- a/bindings/Python/Generated/IR/LLVM/MemmoveOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MemmoveOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1136]) || tp >= &(gTypes[1137])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MemmoveOp::static_kind():
-      tp = &(gTypes[1136]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MemmoveOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemmoveOp::is_volatile"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemmoveOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemmoveOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemmoveOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1136]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MemmoveOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MemmoveOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MemmoveOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MemmoveOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MemmoveOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MemoryEffectsAttr.cpp b/bindings/Python/Generated/IR/LLVM/MemoryEffectsAttr.cpp
deleted file mode 100644
index 2d643dfd7..000000000
--- a/bindings/Python/Generated/IR/LLVM/MemoryEffectsAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MemoryEffectsAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[926]) || tp >= &(gTypes[927])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MemoryEffectsAttr::static_kind():
-      tp = &(gTypes[926]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MemoryEffectsAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_read_write",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_read_write());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemoryEffectsAttr::is_read_write"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemoryEffectsAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemoryEffectsAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[926]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MemoryEffectsAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MemoryEffectsAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MemoryEffectsAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MemoryEffectsAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MemoryEffectsAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MemsetOp.cpp b/bindings/Python/Generated/IR/LLVM/MemsetOp.cpp
deleted file mode 100644
index d291ebdd7..000000000
--- a/bindings/Python/Generated/IR/LLVM/MemsetOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MemsetOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1137]) || tp >= &(gTypes[1138])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MemsetOp::static_kind():
-      tp = &(gTypes[1137]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MemsetOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "is_volatile",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_volatile());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemsetOp::is_volatile"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemsetOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemsetOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MemsetOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1137]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MemsetOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MemsetOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MemsetOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MemsetOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MemsetOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MinNumOp.cpp b/bindings/Python/Generated/IR/LLVM/MinNumOp.cpp
deleted file mode 100644
index 8c45b0fab..000000000
--- a/bindings/Python/Generated/IR/LLVM/MinNumOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MinNumOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1138]) || tp >= &(gTypes[1139])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MinNumOp::static_kind():
-      tp = &(gTypes[1138]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MinNumOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinNumOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinNumOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinNumOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinNumOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinNumOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinNumOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1138]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MinNumOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MinNumOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MinNumOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MinNumOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MinNumOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MinimumOp.cpp b/bindings/Python/Generated/IR/LLVM/MinimumOp.cpp
deleted file mode 100644
index 93d5fa113..000000000
--- a/bindings/Python/Generated/IR/LLVM/MinimumOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MinimumOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1139]) || tp >= &(gTypes[1140])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MinimumOp::static_kind():
-      tp = &(gTypes[1139]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MinimumOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinimumOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinimumOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinimumOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinimumOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinimumOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MinimumOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1139]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MinimumOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MinimumOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MinimumOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MinimumOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MinimumOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/MulOp.cpp b/bindings/Python/Generated/IR/LLVM/MulOp.cpp
deleted file mode 100644
index 5001550a8..000000000
--- a/bindings/Python/Generated/IR/LLVM/MulOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::MulOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1049]) || tp >= &(gTypes[1050])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::MulOp::static_kind():
-      tp = &(gTypes[1049]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MulOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MulOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MulOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MulOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MulOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MulOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::MulOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1049]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.MulOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::MulOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MulOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MulOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MulOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/NoAliasScopeDeclOp.cpp b/bindings/Python/Generated/IR/LLVM/NoAliasScopeDeclOp.cpp
deleted file mode 100644
index e20193661..000000000
--- a/bindings/Python/Generated/IR/LLVM/NoAliasScopeDeclOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::NoAliasScopeDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1141]) || tp >= &(gTypes[1142])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::NoAliasScopeDeclOp::static_kind():
-      tp = &(gTypes[1141]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NoAliasScopeDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::NoAliasScopeDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::NoAliasScopeDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::NoAliasScopeDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1141]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.NoAliasScopeDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::NoAliasScopeDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NoAliasScopeDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NoAliasScopeDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NoAliasScopeDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/NoneTokenOp.cpp b/bindings/Python/Generated/IR/LLVM/NoneTokenOp.cpp
deleted file mode 100644
index 4bf577d19..000000000
--- a/bindings/Python/Generated/IR/LLVM/NoneTokenOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::NoneTokenOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1050]) || tp >= &(gTypes[1051])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::NoneTokenOp::static_kind():
-      tp = &(gTypes[1050]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "NoneTokenOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::NoneTokenOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::NoneTokenOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::NoneTokenOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::NoneTokenOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1050]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.NoneTokenOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::NoneTokenOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'NoneTokenOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'NoneTokenOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'NoneTokenOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/Operation.cpp b/bindings/Python/Generated/IR/LLVM/Operation.cpp
deleted file mode 100644
index 02e714a6a..000000000
--- a/bindings/Python/Generated/IR/LLVM/Operation.cpp
+++ /dev/null
@@ -1,1205 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::Operation;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1002]) || tp >= &(gTypes[1251])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::AShrOp::static_kind():
-      tp = &(gTypes[1003]);
-      break;
-
-    case mx::ir::llvm::AddOp::static_kind():
-      tp = &(gTypes[1004]);
-      break;
-
-    case mx::ir::llvm::AddrSpaceCastOp::static_kind():
-      tp = &(gTypes[1005]);
-      break;
-
-    case mx::ir::llvm::AddressOfOp::static_kind():
-      tp = &(gTypes[1006]);
-      break;
-
-    case mx::ir::llvm::AllocaOp::static_kind():
-      tp = &(gTypes[1007]);
-      break;
-
-    case mx::ir::llvm::AndOp::static_kind():
-      tp = &(gTypes[1008]);
-      break;
-
-    case mx::ir::llvm::AtomicCmpXchgOp::static_kind():
-      tp = &(gTypes[1009]);
-      break;
-
-    case mx::ir::llvm::AtomicRMWOp::static_kind():
-      tp = &(gTypes[1010]);
-      break;
-
-    case mx::ir::llvm::BitcastOp::static_kind():
-      tp = &(gTypes[1011]);
-      break;
-
-    case mx::ir::llvm::BrOp::static_kind():
-      tp = &(gTypes[1012]);
-      break;
-
-    case mx::ir::llvm::CallIntrinsicOp::static_kind():
-      tp = &(gTypes[1013]);
-      break;
-
-    case mx::ir::llvm::CallOp::static_kind():
-      tp = &(gTypes[1014]);
-      break;
-
-    case mx::ir::llvm::ComdatOp::static_kind():
-      tp = &(gTypes[1015]);
-      break;
-
-    case mx::ir::llvm::ComdatSelectorOp::static_kind():
-      tp = &(gTypes[1016]);
-      break;
-
-    case mx::ir::llvm::CondBrOp::static_kind():
-      tp = &(gTypes[1017]);
-      break;
-
-    case mx::ir::llvm::ConstantOp::static_kind():
-      tp = &(gTypes[1018]);
-      break;
-
-    case mx::ir::llvm::ExtractElementOp::static_kind():
-      tp = &(gTypes[1019]);
-      break;
-
-    case mx::ir::llvm::ExtractValueOp::static_kind():
-      tp = &(gTypes[1020]);
-      break;
-
-    case mx::ir::llvm::FAddOp::static_kind():
-      tp = &(gTypes[1021]);
-      break;
-
-    case mx::ir::llvm::FCmpOp::static_kind():
-      tp = &(gTypes[1022]);
-      break;
-
-    case mx::ir::llvm::FDivOp::static_kind():
-      tp = &(gTypes[1023]);
-      break;
-
-    case mx::ir::llvm::FMulOp::static_kind():
-      tp = &(gTypes[1024]);
-      break;
-
-    case mx::ir::llvm::FNegOp::static_kind():
-      tp = &(gTypes[1025]);
-      break;
-
-    case mx::ir::llvm::FPExtOp::static_kind():
-      tp = &(gTypes[1026]);
-      break;
-
-    case mx::ir::llvm::FPToSIOp::static_kind():
-      tp = &(gTypes[1027]);
-      break;
-
-    case mx::ir::llvm::FPToUIOp::static_kind():
-      tp = &(gTypes[1028]);
-      break;
-
-    case mx::ir::llvm::FPTruncOp::static_kind():
-      tp = &(gTypes[1029]);
-      break;
-
-    case mx::ir::llvm::FRemOp::static_kind():
-      tp = &(gTypes[1030]);
-      break;
-
-    case mx::ir::llvm::FSubOp::static_kind():
-      tp = &(gTypes[1031]);
-      break;
-
-    case mx::ir::llvm::FenceOp::static_kind():
-      tp = &(gTypes[1032]);
-      break;
-
-    case mx::ir::llvm::FreezeOp::static_kind():
-      tp = &(gTypes[1033]);
-      break;
-
-    case mx::ir::llvm::GetElementPtrOp::static_kind():
-      tp = &(gTypes[1034]);
-      break;
-
-    case mx::ir::llvm::GlobalCtorsOp::static_kind():
-      tp = &(gTypes[1035]);
-      break;
-
-    case mx::ir::llvm::GlobalDtorsOp::static_kind():
-      tp = &(gTypes[1036]);
-      break;
-
-    case mx::ir::llvm::GlobalOp::static_kind():
-      tp = &(gTypes[1037]);
-      break;
-
-    case mx::ir::llvm::ICmpOp::static_kind():
-      tp = &(gTypes[1038]);
-      break;
-
-    case mx::ir::llvm::InlineAsmOp::static_kind():
-      tp = &(gTypes[1039]);
-      break;
-
-    case mx::ir::llvm::InsertElementOp::static_kind():
-      tp = &(gTypes[1040]);
-      break;
-
-    case mx::ir::llvm::InsertValueOp::static_kind():
-      tp = &(gTypes[1041]);
-      break;
-
-    case mx::ir::llvm::IntToPtrOp::static_kind():
-      tp = &(gTypes[1042]);
-      break;
-
-    case mx::ir::llvm::InvokeOp::static_kind():
-      tp = &(gTypes[1043]);
-      break;
-
-    case mx::ir::llvm::FuncOp::static_kind():
-      tp = &(gTypes[1044]);
-      break;
-
-    case mx::ir::llvm::LShrOp::static_kind():
-      tp = &(gTypes[1045]);
-      break;
-
-    case mx::ir::llvm::LandingpadOp::static_kind():
-      tp = &(gTypes[1046]);
-      break;
-
-    case mx::ir::llvm::LinkerOptionsOp::static_kind():
-      tp = &(gTypes[1047]);
-      break;
-
-    case mx::ir::llvm::LoadOp::static_kind():
-      tp = &(gTypes[1048]);
-      break;
-
-    case mx::ir::llvm::MulOp::static_kind():
-      tp = &(gTypes[1049]);
-      break;
-
-    case mx::ir::llvm::NoneTokenOp::static_kind():
-      tp = &(gTypes[1050]);
-      break;
-
-    case mx::ir::llvm::OrOp::static_kind():
-      tp = &(gTypes[1051]);
-      break;
-
-    case mx::ir::llvm::PoisonOp::static_kind():
-      tp = &(gTypes[1052]);
-      break;
-
-    case mx::ir::llvm::PtrToIntOp::static_kind():
-      tp = &(gTypes[1053]);
-      break;
-
-    case mx::ir::llvm::ResumeOp::static_kind():
-      tp = &(gTypes[1054]);
-      break;
-
-    case mx::ir::llvm::ReturnOp::static_kind():
-      tp = &(gTypes[1055]);
-      break;
-
-    case mx::ir::llvm::SDivOp::static_kind():
-      tp = &(gTypes[1056]);
-      break;
-
-    case mx::ir::llvm::SExtOp::static_kind():
-      tp = &(gTypes[1057]);
-      break;
-
-    case mx::ir::llvm::SIToFPOp::static_kind():
-      tp = &(gTypes[1058]);
-      break;
-
-    case mx::ir::llvm::SRemOp::static_kind():
-      tp = &(gTypes[1059]);
-      break;
-
-    case mx::ir::llvm::SelectOp::static_kind():
-      tp = &(gTypes[1060]);
-      break;
-
-    case mx::ir::llvm::ShlOp::static_kind():
-      tp = &(gTypes[1061]);
-      break;
-
-    case mx::ir::llvm::ShuffleVectorOp::static_kind():
-      tp = &(gTypes[1062]);
-      break;
-
-    case mx::ir::llvm::StoreOp::static_kind():
-      tp = &(gTypes[1063]);
-      break;
-
-    case mx::ir::llvm::SubOp::static_kind():
-      tp = &(gTypes[1064]);
-      break;
-
-    case mx::ir::llvm::SwitchOp::static_kind():
-      tp = &(gTypes[1065]);
-      break;
-
-    case mx::ir::llvm::TruncOp::static_kind():
-      tp = &(gTypes[1066]);
-      break;
-
-    case mx::ir::llvm::UDivOp::static_kind():
-      tp = &(gTypes[1067]);
-      break;
-
-    case mx::ir::llvm::UIToFPOp::static_kind():
-      tp = &(gTypes[1068]);
-      break;
-
-    case mx::ir::llvm::URemOp::static_kind():
-      tp = &(gTypes[1069]);
-      break;
-
-    case mx::ir::llvm::UndefOp::static_kind():
-      tp = &(gTypes[1070]);
-      break;
-
-    case mx::ir::llvm::UnreachableOp::static_kind():
-      tp = &(gTypes[1071]);
-      break;
-
-    case mx::ir::llvm::XOrOp::static_kind():
-      tp = &(gTypes[1072]);
-      break;
-
-    case mx::ir::llvm::ZExtOp::static_kind():
-      tp = &(gTypes[1073]);
-      break;
-
-    case mx::ir::llvm::ZeroOp::static_kind():
-      tp = &(gTypes[1074]);
-      break;
-
-    case mx::ir::llvm::AbsOp::static_kind():
-      tp = &(gTypes[1075]);
-      break;
-
-    case mx::ir::llvm::AnnotationOp::static_kind():
-      tp = &(gTypes[1076]);
-      break;
-
-    case mx::ir::llvm::AssumeOp::static_kind():
-      tp = &(gTypes[1077]);
-      break;
-
-    case mx::ir::llvm::BitReverseOp::static_kind():
-      tp = &(gTypes[1078]);
-      break;
-
-    case mx::ir::llvm::ByteSwapOp::static_kind():
-      tp = &(gTypes[1079]);
-      break;
-
-    case mx::ir::llvm::CopySignOp::static_kind():
-      tp = &(gTypes[1080]);
-      break;
-
-    case mx::ir::llvm::CoroAlignOp::static_kind():
-      tp = &(gTypes[1081]);
-      break;
-
-    case mx::ir::llvm::CoroBeginOp::static_kind():
-      tp = &(gTypes[1082]);
-      break;
-
-    case mx::ir::llvm::CoroEndOp::static_kind():
-      tp = &(gTypes[1083]);
-      break;
-
-    case mx::ir::llvm::CoroFreeOp::static_kind():
-      tp = &(gTypes[1084]);
-      break;
-
-    case mx::ir::llvm::CoroIdOp::static_kind():
-      tp = &(gTypes[1085]);
-      break;
-
-    case mx::ir::llvm::CoroPromiseOp::static_kind():
-      tp = &(gTypes[1086]);
-      break;
-
-    case mx::ir::llvm::CoroResumeOp::static_kind():
-      tp = &(gTypes[1087]);
-      break;
-
-    case mx::ir::llvm::CoroSaveOp::static_kind():
-      tp = &(gTypes[1088]);
-      break;
-
-    case mx::ir::llvm::CoroSizeOp::static_kind():
-      tp = &(gTypes[1089]);
-      break;
-
-    case mx::ir::llvm::CoroSuspendOp::static_kind():
-      tp = &(gTypes[1090]);
-      break;
-
-    case mx::ir::llvm::CosOp::static_kind():
-      tp = &(gTypes[1091]);
-      break;
-
-    case mx::ir::llvm::CountLeadingZerosOp::static_kind():
-      tp = &(gTypes[1092]);
-      break;
-
-    case mx::ir::llvm::CountTrailingZerosOp::static_kind():
-      tp = &(gTypes[1093]);
-      break;
-
-    case mx::ir::llvm::CtPopOp::static_kind():
-      tp = &(gTypes[1094]);
-      break;
-
-    case mx::ir::llvm::DbgDeclareOp::static_kind():
-      tp = &(gTypes[1095]);
-      break;
-
-    case mx::ir::llvm::DbgLabelOp::static_kind():
-      tp = &(gTypes[1096]);
-      break;
-
-    case mx::ir::llvm::DbgValueOp::static_kind():
-      tp = &(gTypes[1097]);
-      break;
-
-    case mx::ir::llvm::DebugTrapOp::static_kind():
-      tp = &(gTypes[1098]);
-      break;
-
-    case mx::ir::llvm::EhTypeidForOp::static_kind():
-      tp = &(gTypes[1099]);
-      break;
-
-    case mx::ir::llvm::Exp2Op::static_kind():
-      tp = &(gTypes[1100]);
-      break;
-
-    case mx::ir::llvm::ExpOp::static_kind():
-      tp = &(gTypes[1101]);
-      break;
-
-    case mx::ir::llvm::ExpectOp::static_kind():
-      tp = &(gTypes[1102]);
-      break;
-
-    case mx::ir::llvm::ExpectWithProbabilityOp::static_kind():
-      tp = &(gTypes[1103]);
-      break;
-
-    case mx::ir::llvm::FAbsOp::static_kind():
-      tp = &(gTypes[1104]);
-      break;
-
-    case mx::ir::llvm::FCeilOp::static_kind():
-      tp = &(gTypes[1105]);
-      break;
-
-    case mx::ir::llvm::FFloorOp::static_kind():
-      tp = &(gTypes[1106]);
-      break;
-
-    case mx::ir::llvm::FMAOp::static_kind():
-      tp = &(gTypes[1107]);
-      break;
-
-    case mx::ir::llvm::FMulAddOp::static_kind():
-      tp = &(gTypes[1108]);
-      break;
-
-    case mx::ir::llvm::FTruncOp::static_kind():
-      tp = &(gTypes[1109]);
-      break;
-
-    case mx::ir::llvm::FShlOp::static_kind():
-      tp = &(gTypes[1110]);
-      break;
-
-    case mx::ir::llvm::FShrOp::static_kind():
-      tp = &(gTypes[1111]);
-      break;
-
-    case mx::ir::llvm::GetActiveLaneMaskOp::static_kind():
-      tp = &(gTypes[1112]);
-      break;
-
-    case mx::ir::llvm::InvariantEndOp::static_kind():
-      tp = &(gTypes[1113]);
-      break;
-
-    case mx::ir::llvm::InvariantStartOp::static_kind():
-      tp = &(gTypes[1114]);
-      break;
-
-    case mx::ir::llvm::IsConstantOp::static_kind():
-      tp = &(gTypes[1115]);
-      break;
-
-    case mx::ir::llvm::IsFPClassOp::static_kind():
-      tp = &(gTypes[1116]);
-      break;
-
-    case mx::ir::llvm::LifetimeEndOp::static_kind():
-      tp = &(gTypes[1117]);
-      break;
-
-    case mx::ir::llvm::LifetimeStartOp::static_kind():
-      tp = &(gTypes[1118]);
-      break;
-
-    case mx::ir::llvm::RoundAndCastToLongLongOp::static_kind():
-      tp = &(gTypes[1119]);
-      break;
-
-    case mx::ir::llvm::RoundAndCastToNearestLongLongOp::static_kind():
-      tp = &(gTypes[1120]);
-      break;
-
-    case mx::ir::llvm::Log10Op::static_kind():
-      tp = &(gTypes[1121]);
-      break;
-
-    case mx::ir::llvm::Log2Op::static_kind():
-      tp = &(gTypes[1122]);
-      break;
-
-    case mx::ir::llvm::LogOp::static_kind():
-      tp = &(gTypes[1123]);
-      break;
-
-    case mx::ir::llvm::RoundAndCastToLongOp::static_kind():
-      tp = &(gTypes[1124]);
-      break;
-
-    case mx::ir::llvm::RoundAndCastToNearestLongOp::static_kind():
-      tp = &(gTypes[1125]);
-      break;
-
-    case mx::ir::llvm::MaskedLoadOp::static_kind():
-      tp = &(gTypes[1126]);
-      break;
-
-    case mx::ir::llvm::MaskedStoreOp::static_kind():
-      tp = &(gTypes[1127]);
-      break;
-
-    case mx::ir::llvm::MatrixColumnMajorLoadOp::static_kind():
-      tp = &(gTypes[1128]);
-      break;
-
-    case mx::ir::llvm::MatrixColumnMajorStoreOp::static_kind():
-      tp = &(gTypes[1129]);
-      break;
-
-    case mx::ir::llvm::MatrixMultiplyOp::static_kind():
-      tp = &(gTypes[1130]);
-      break;
-
-    case mx::ir::llvm::MatrixTransposeOp::static_kind():
-      tp = &(gTypes[1131]);
-      break;
-
-    case mx::ir::llvm::MaxNumOp::static_kind():
-      tp = &(gTypes[1132]);
-      break;
-
-    case mx::ir::llvm::MaximumOp::static_kind():
-      tp = &(gTypes[1133]);
-      break;
-
-    case mx::ir::llvm::MemcpyInlineOp::static_kind():
-      tp = &(gTypes[1134]);
-      break;
-
-    case mx::ir::llvm::MemcpyOp::static_kind():
-      tp = &(gTypes[1135]);
-      break;
-
-    case mx::ir::llvm::MemmoveOp::static_kind():
-      tp = &(gTypes[1136]);
-      break;
-
-    case mx::ir::llvm::MemsetOp::static_kind():
-      tp = &(gTypes[1137]);
-      break;
-
-    case mx::ir::llvm::MinNumOp::static_kind():
-      tp = &(gTypes[1138]);
-      break;
-
-    case mx::ir::llvm::MinimumOp::static_kind():
-      tp = &(gTypes[1139]);
-      break;
-
-    case mx::ir::llvm::RoundToNearbyIntOp::static_kind():
-      tp = &(gTypes[1140]);
-      break;
-
-    case mx::ir::llvm::NoAliasScopeDeclOp::static_kind():
-      tp = &(gTypes[1141]);
-      break;
-
-    case mx::ir::llvm::PowIOp::static_kind():
-      tp = &(gTypes[1142]);
-      break;
-
-    case mx::ir::llvm::FPowOp::static_kind():
-      tp = &(gTypes[1143]);
-      break;
-
-    case mx::ir::llvm::PrefetchOp::static_kind():
-      tp = &(gTypes[1144]);
-      break;
-
-    case mx::ir::llvm::PtrAnnotationOp::static_kind():
-      tp = &(gTypes[1145]);
-      break;
-
-    case mx::ir::llvm::RoundToIntOp::static_kind():
-      tp = &(gTypes[1146]);
-      break;
-
-    case mx::ir::llvm::RoundToNearestEvenOp::static_kind():
-      tp = &(gTypes[1147]);
-      break;
-
-    case mx::ir::llvm::RoundToNearestOp::static_kind():
-      tp = &(gTypes[1148]);
-      break;
-
-    case mx::ir::llvm::SAddSatOp::static_kind():
-      tp = &(gTypes[1149]);
-      break;
-
-    case mx::ir::llvm::SAddWithOverflowOp::static_kind():
-      tp = &(gTypes[1150]);
-      break;
-
-    case mx::ir::llvm::SMaxOp::static_kind():
-      tp = &(gTypes[1151]);
-      break;
-
-    case mx::ir::llvm::SMinOp::static_kind():
-      tp = &(gTypes[1152]);
-      break;
-
-    case mx::ir::llvm::SMulWithOverflowOp::static_kind():
-      tp = &(gTypes[1153]);
-      break;
-
-    case mx::ir::llvm::SSACopyOp::static_kind():
-      tp = &(gTypes[1154]);
-      break;
-
-    case mx::ir::llvm::SShlSatOp::static_kind():
-      tp = &(gTypes[1155]);
-      break;
-
-    case mx::ir::llvm::SSubSatOp::static_kind():
-      tp = &(gTypes[1156]);
-      break;
-
-    case mx::ir::llvm::SSubWithOverflowOp::static_kind():
-      tp = &(gTypes[1157]);
-      break;
-
-    case mx::ir::llvm::SinOp::static_kind():
-      tp = &(gTypes[1158]);
-      break;
-
-    case mx::ir::llvm::SqrtOp::static_kind():
-      tp = &(gTypes[1159]);
-      break;
-
-    case mx::ir::llvm::StackRestoreOp::static_kind():
-      tp = &(gTypes[1160]);
-      break;
-
-    case mx::ir::llvm::StackSaveOp::static_kind():
-      tp = &(gTypes[1161]);
-      break;
-
-    case mx::ir::llvm::StepVectorOp::static_kind():
-      tp = &(gTypes[1162]);
-      break;
-
-    case mx::ir::llvm::ThreadLocalAddressOp::static_kind():
-      tp = &(gTypes[1163]);
-      break;
-
-    case mx::ir::llvm::TrapOp::static_kind():
-      tp = &(gTypes[1164]);
-      break;
-
-    case mx::ir::llvm::UAddSatOp::static_kind():
-      tp = &(gTypes[1165]);
-      break;
-
-    case mx::ir::llvm::UAddWithOverflowOp::static_kind():
-      tp = &(gTypes[1166]);
-      break;
-
-    case mx::ir::llvm::UBSanTrapOp::static_kind():
-      tp = &(gTypes[1167]);
-      break;
-
-    case mx::ir::llvm::UMaxOp::static_kind():
-      tp = &(gTypes[1168]);
-      break;
-
-    case mx::ir::llvm::UMinOp::static_kind():
-      tp = &(gTypes[1169]);
-      break;
-
-    case mx::ir::llvm::UMulWithOverflowOp::static_kind():
-      tp = &(gTypes[1170]);
-      break;
-
-    case mx::ir::llvm::UShlSatOp::static_kind():
-      tp = &(gTypes[1171]);
-      break;
-
-    case mx::ir::llvm::USubSatOp::static_kind():
-      tp = &(gTypes[1172]);
-      break;
-
-    case mx::ir::llvm::USubWithOverflowOp::static_kind():
-      tp = &(gTypes[1173]);
-      break;
-
-    case mx::ir::llvm::VPAShrOp::static_kind():
-      tp = &(gTypes[1174]);
-      break;
-
-    case mx::ir::llvm::VPAddOp::static_kind():
-      tp = &(gTypes[1175]);
-      break;
-
-    case mx::ir::llvm::VPAndOp::static_kind():
-      tp = &(gTypes[1176]);
-      break;
-
-    case mx::ir::llvm::VPFAddOp::static_kind():
-      tp = &(gTypes[1177]);
-      break;
-
-    case mx::ir::llvm::VPFDivOp::static_kind():
-      tp = &(gTypes[1178]);
-      break;
-
-    case mx::ir::llvm::VPFMulAddOp::static_kind():
-      tp = &(gTypes[1179]);
-      break;
-
-    case mx::ir::llvm::VPFMulOp::static_kind():
-      tp = &(gTypes[1180]);
-      break;
-
-    case mx::ir::llvm::VPFNegOp::static_kind():
-      tp = &(gTypes[1181]);
-      break;
-
-    case mx::ir::llvm::VPFPExtOp::static_kind():
-      tp = &(gTypes[1182]);
-      break;
-
-    case mx::ir::llvm::VPFPToSIOp::static_kind():
-      tp = &(gTypes[1183]);
-      break;
-
-    case mx::ir::llvm::VPFPToUIOp::static_kind():
-      tp = &(gTypes[1184]);
-      break;
-
-    case mx::ir::llvm::VPFPTruncOp::static_kind():
-      tp = &(gTypes[1185]);
-      break;
-
-    case mx::ir::llvm::VPFRemOp::static_kind():
-      tp = &(gTypes[1186]);
-      break;
-
-    case mx::ir::llvm::VPFSubOp::static_kind():
-      tp = &(gTypes[1187]);
-      break;
-
-    case mx::ir::llvm::VPFmaOp::static_kind():
-      tp = &(gTypes[1188]);
-      break;
-
-    case mx::ir::llvm::VPIntToPtrOp::static_kind():
-      tp = &(gTypes[1189]);
-      break;
-
-    case mx::ir::llvm::VPLShrOp::static_kind():
-      tp = &(gTypes[1190]);
-      break;
-
-    case mx::ir::llvm::VPLoadOp::static_kind():
-      tp = &(gTypes[1191]);
-      break;
-
-    case mx::ir::llvm::VPMergeMinOp::static_kind():
-      tp = &(gTypes[1192]);
-      break;
-
-    case mx::ir::llvm::VPMulOp::static_kind():
-      tp = &(gTypes[1193]);
-      break;
-
-    case mx::ir::llvm::VPOrOp::static_kind():
-      tp = &(gTypes[1194]);
-      break;
-
-    case mx::ir::llvm::VPPtrToIntOp::static_kind():
-      tp = &(gTypes[1195]);
-      break;
-
-    case mx::ir::llvm::VPReduceAddOp::static_kind():
-      tp = &(gTypes[1196]);
-      break;
-
-    case mx::ir::llvm::VPReduceAndOp::static_kind():
-      tp = &(gTypes[1197]);
-      break;
-
-    case mx::ir::llvm::VPReduceFAddOp::static_kind():
-      tp = &(gTypes[1198]);
-      break;
-
-    case mx::ir::llvm::VPReduceFMaxOp::static_kind():
-      tp = &(gTypes[1199]);
-      break;
-
-    case mx::ir::llvm::VPReduceFMinOp::static_kind():
-      tp = &(gTypes[1200]);
-      break;
-
-    case mx::ir::llvm::VPReduceFMulOp::static_kind():
-      tp = &(gTypes[1201]);
-      break;
-
-    case mx::ir::llvm::VPReduceMulOp::static_kind():
-      tp = &(gTypes[1202]);
-      break;
-
-    case mx::ir::llvm::VPReduceOrOp::static_kind():
-      tp = &(gTypes[1203]);
-      break;
-
-    case mx::ir::llvm::VPReduceSMaxOp::static_kind():
-      tp = &(gTypes[1204]);
-      break;
-
-    case mx::ir::llvm::VPReduceSMinOp::static_kind():
-      tp = &(gTypes[1205]);
-      break;
-
-    case mx::ir::llvm::VPReduceUMaxOp::static_kind():
-      tp = &(gTypes[1206]);
-      break;
-
-    case mx::ir::llvm::VPReduceUMinOp::static_kind():
-      tp = &(gTypes[1207]);
-      break;
-
-    case mx::ir::llvm::VPReduceXorOp::static_kind():
-      tp = &(gTypes[1208]);
-      break;
-
-    case mx::ir::llvm::VPSDivOp::static_kind():
-      tp = &(gTypes[1209]);
-      break;
-
-    case mx::ir::llvm::VPSExtOp::static_kind():
-      tp = &(gTypes[1210]);
-      break;
-
-    case mx::ir::llvm::VPSIToFPOp::static_kind():
-      tp = &(gTypes[1211]);
-      break;
-
-    case mx::ir::llvm::VPSRemOp::static_kind():
-      tp = &(gTypes[1212]);
-      break;
-
-    case mx::ir::llvm::VPSelectMinOp::static_kind():
-      tp = &(gTypes[1213]);
-      break;
-
-    case mx::ir::llvm::VPShlOp::static_kind():
-      tp = &(gTypes[1214]);
-      break;
-
-    case mx::ir::llvm::VPStoreOp::static_kind():
-      tp = &(gTypes[1215]);
-      break;
-
-    case mx::ir::llvm::VPStridedLoadOp::static_kind():
-      tp = &(gTypes[1216]);
-      break;
-
-    case mx::ir::llvm::VPStridedStoreOp::static_kind():
-      tp = &(gTypes[1217]);
-      break;
-
-    case mx::ir::llvm::VPSubOp::static_kind():
-      tp = &(gTypes[1218]);
-      break;
-
-    case mx::ir::llvm::VPTruncOp::static_kind():
-      tp = &(gTypes[1219]);
-      break;
-
-    case mx::ir::llvm::VPUDivOp::static_kind():
-      tp = &(gTypes[1220]);
-      break;
-
-    case mx::ir::llvm::VPUIToFPOp::static_kind():
-      tp = &(gTypes[1221]);
-      break;
-
-    case mx::ir::llvm::VPURemOp::static_kind():
-      tp = &(gTypes[1222]);
-      break;
-
-    case mx::ir::llvm::VPXorOp::static_kind():
-      tp = &(gTypes[1223]);
-      break;
-
-    case mx::ir::llvm::VPZExtOp::static_kind():
-      tp = &(gTypes[1224]);
-      break;
-
-    case mx::ir::llvm::VaCopyOp::static_kind():
-      tp = &(gTypes[1225]);
-      break;
-
-    case mx::ir::llvm::VaEndOp::static_kind():
-      tp = &(gTypes[1226]);
-      break;
-
-    case mx::ir::llvm::VaStartOp::static_kind():
-      tp = &(gTypes[1227]);
-      break;
-
-    case mx::ir::llvm::VarAnnotationOp::static_kind():
-      tp = &(gTypes[1228]);
-      break;
-
-    case mx::ir::llvm::MaskedCompressStoreOp::static_kind():
-      tp = &(gTypes[1229]);
-      break;
-
-    case mx::ir::llvm::MaskedExpandLoadOp::static_kind():
-      tp = &(gTypes[1230]);
-      break;
-
-    case mx::ir::llvm::MaskedGatherOp::static_kind():
-      tp = &(gTypes[1231]);
-      break;
-
-    case mx::ir::llvm::MaskedScatterOp::static_kind():
-      tp = &(gTypes[1232]);
-      break;
-
-    case mx::ir::llvm::VectorExtractOp::static_kind():
-      tp = &(gTypes[1233]);
-      break;
-
-    case mx::ir::llvm::VectorInsertOp::static_kind():
-      tp = &(gTypes[1234]);
-      break;
-
-    case mx::ir::llvm::VectorReduceAddOp::static_kind():
-      tp = &(gTypes[1235]);
-      break;
-
-    case mx::ir::llvm::VectorReduceAndOp::static_kind():
-      tp = &(gTypes[1236]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFAddOp::static_kind():
-      tp = &(gTypes[1237]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMaxOp::static_kind():
-      tp = &(gTypes[1238]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMaximumOp::static_kind():
-      tp = &(gTypes[1239]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMinOp::static_kind():
-      tp = &(gTypes[1240]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMinimumOp::static_kind():
-      tp = &(gTypes[1241]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMulOp::static_kind():
-      tp = &(gTypes[1242]);
-      break;
-
-    case mx::ir::llvm::VectorReduceMulOp::static_kind():
-      tp = &(gTypes[1243]);
-      break;
-
-    case mx::ir::llvm::VectorReduceOrOp::static_kind():
-      tp = &(gTypes[1244]);
-      break;
-
-    case mx::ir::llvm::VectorReduceSMaxOp::static_kind():
-      tp = &(gTypes[1245]);
-      break;
-
-    case mx::ir::llvm::VectorReduceSMinOp::static_kind():
-      tp = &(gTypes[1246]);
-      break;
-
-    case mx::ir::llvm::VectorReduceUMaxOp::static_kind():
-      tp = &(gTypes[1247]);
-      break;
-
-    case mx::ir::llvm::VectorReduceUMinOp::static_kind():
-      tp = &(gTypes[1248]);
-      break;
-
-    case mx::ir::llvm::VectorReduceXorOp::static_kind():
-      tp = &(gTypes[1249]);
-      break;
-
-    case mx::ir::llvm::VScaleOp::static_kind():
-      tp = &(gTypes[1250]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operation", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Operation::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1002]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.Operation";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::Operation");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[998].tp_hash;
-  tp->tp_richcompare = gTypes[998].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[998]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operation.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operation.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operation' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/OrOp.cpp b/bindings/Python/Generated/IR/LLVM/OrOp.cpp
deleted file mode 100644
index e12cb0710..000000000
--- a/bindings/Python/Generated/IR/LLVM/OrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::OrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1051]) || tp >= &(gTypes[1052])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::OrOp::static_kind():
-      tp = &(gTypes[1051]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "OrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::OrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::OrOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::OrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::OrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::OrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::OrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1051]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.OrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::OrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'OrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'OrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'OrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/PointerType.cpp b/bindings/Python/Generated/IR/LLVM/PointerType.cpp
deleted file mode 100644
index fd3c24be5..000000000
--- a/bindings/Python/Generated/IR/LLVM/PointerType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::PointerType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1492]) || tp >= &(gTypes[1493])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::PointerType::static_kind():
-      tp = &(gTypes[1492]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PointerType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "address_space",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->address_space());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PointerType::address_space"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PointerType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PointerType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1492]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.PointerType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::PointerType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1489].tp_hash;
-  tp->tp_richcompare = gTypes[1489].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1489]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PointerType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PointerType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PointerType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/PoisonOp.cpp b/bindings/Python/Generated/IR/LLVM/PoisonOp.cpp
deleted file mode 100644
index 9d0b6cdd8..000000000
--- a/bindings/Python/Generated/IR/LLVM/PoisonOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::PoisonOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1052]) || tp >= &(gTypes[1053])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::PoisonOp::static_kind():
-      tp = &(gTypes[1052]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PoisonOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PoisonOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PoisonOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PoisonOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PoisonOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1052]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.PoisonOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::PoisonOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PoisonOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PoisonOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PoisonOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/PowIOp.cpp b/bindings/Python/Generated/IR/LLVM/PowIOp.cpp
deleted file mode 100644
index bd3d801fb..000000000
--- a/bindings/Python/Generated/IR/LLVM/PowIOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::PowIOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1142]) || tp >= &(gTypes[1143])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::PowIOp::static_kind():
-      tp = &(gTypes[1142]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PowIOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PowIOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PowIOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PowIOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PowIOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PowIOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1142]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.PowIOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::PowIOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PowIOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PowIOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PowIOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/PrefetchOp.cpp b/bindings/Python/Generated/IR/LLVM/PrefetchOp.cpp
deleted file mode 100644
index db5b208e5..000000000
--- a/bindings/Python/Generated/IR/LLVM/PrefetchOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::PrefetchOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1144]) || tp >= &(gTypes[1145])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::PrefetchOp::static_kind():
-      tp = &(gTypes[1144]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PrefetchOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "rw",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->rw());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PrefetchOp::rw"),
-    nullptr,
-  },
-  {
-    "hint",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->hint());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PrefetchOp::hint"),
-    nullptr,
-  },
-  {
-    "cache",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->cache());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PrefetchOp::cache"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PrefetchOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PrefetchOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PrefetchOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1144]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.PrefetchOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::PrefetchOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PrefetchOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PrefetchOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PrefetchOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/PtrAnnotationOp.cpp b/bindings/Python/Generated/IR/LLVM/PtrAnnotationOp.cpp
deleted file mode 100644
index 9d71e6d50..000000000
--- a/bindings/Python/Generated/IR/LLVM/PtrAnnotationOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::PtrAnnotationOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1145]) || tp >= &(gTypes[1146])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::PtrAnnotationOp::static_kind():
-      tp = &(gTypes[1145]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PtrAnnotationOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PtrAnnotationOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PtrAnnotationOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PtrAnnotationOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1145]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.PtrAnnotationOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::PtrAnnotationOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PtrAnnotationOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PtrAnnotationOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PtrAnnotationOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/PtrToIntOp.cpp b/bindings/Python/Generated/IR/LLVM/PtrToIntOp.cpp
deleted file mode 100644
index 5d27aaebd..000000000
--- a/bindings/Python/Generated/IR/LLVM/PtrToIntOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::PtrToIntOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1053]) || tp >= &(gTypes[1054])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::PtrToIntOp::static_kind():
-      tp = &(gTypes[1053]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PtrToIntOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PtrToIntOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PtrToIntOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PtrToIntOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PtrToIntOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::PtrToIntOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1053]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.PtrToIntOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::PtrToIntOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PtrToIntOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PtrToIntOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PtrToIntOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ResumeOp.cpp b/bindings/Python/Generated/IR/LLVM/ResumeOp.cpp
deleted file mode 100644
index 1c5fbba7d..000000000
--- a/bindings/Python/Generated/IR/LLVM/ResumeOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ResumeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1054]) || tp >= &(gTypes[1055])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ResumeOp::static_kind():
-      tp = &(gTypes[1054]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ResumeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ResumeOp::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ResumeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ResumeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ResumeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1054]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ResumeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ResumeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ResumeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ResumeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ResumeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ReturnOp.cpp b/bindings/Python/Generated/IR/LLVM/ReturnOp.cpp
deleted file mode 100644
index 9dc07c818..000000000
--- a/bindings/Python/Generated/IR/LLVM/ReturnOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ReturnOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1055]) || tp >= &(gTypes[1056])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ReturnOp::static_kind():
-      tp = &(gTypes[1055]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ReturnOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ReturnOp::argument"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ReturnOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ReturnOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ReturnOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1055]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ReturnOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ReturnOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ReturnOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ReturnOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ReturnOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/RoundAndCastToLongLongOp.cpp b/bindings/Python/Generated/IR/LLVM/RoundAndCastToLongLongOp.cpp
deleted file mode 100644
index 08851715b..000000000
--- a/bindings/Python/Generated/IR/LLVM/RoundAndCastToLongLongOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::RoundAndCastToLongLongOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1119]) || tp >= &(gTypes[1120])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::RoundAndCastToLongLongOp::static_kind():
-      tp = &(gTypes[1119]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RoundAndCastToLongLongOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongLongOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongLongOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongLongOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongLongOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongLongOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1119]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.RoundAndCastToLongLongOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::RoundAndCastToLongLongOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RoundAndCastToLongLongOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RoundAndCastToLongLongOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RoundAndCastToLongLongOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/RoundAndCastToLongOp.cpp b/bindings/Python/Generated/IR/LLVM/RoundAndCastToLongOp.cpp
deleted file mode 100644
index 0bdd65a79..000000000
--- a/bindings/Python/Generated/IR/LLVM/RoundAndCastToLongOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::RoundAndCastToLongOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1124]) || tp >= &(gTypes[1125])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::RoundAndCastToLongOp::static_kind():
-      tp = &(gTypes[1124]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RoundAndCastToLongOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToLongOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1124]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.RoundAndCastToLongOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::RoundAndCastToLongOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RoundAndCastToLongOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RoundAndCastToLongOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RoundAndCastToLongOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/RoundAndCastToNearestLongLongOp.cpp b/bindings/Python/Generated/IR/LLVM/RoundAndCastToNearestLongLongOp.cpp
deleted file mode 100644
index 1a71bef2c..000000000
--- a/bindings/Python/Generated/IR/LLVM/RoundAndCastToNearestLongLongOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::RoundAndCastToNearestLongLongOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1120]) || tp >= &(gTypes[1121])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::RoundAndCastToNearestLongLongOp::static_kind():
-      tp = &(gTypes[1120]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RoundAndCastToNearestLongLongOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongLongOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongLongOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongLongOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongLongOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongLongOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1120]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.RoundAndCastToNearestLongLongOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::RoundAndCastToNearestLongLongOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RoundAndCastToNearestLongLongOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RoundAndCastToNearestLongLongOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RoundAndCastToNearestLongLongOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/RoundAndCastToNearestLongOp.cpp b/bindings/Python/Generated/IR/LLVM/RoundAndCastToNearestLongOp.cpp
deleted file mode 100644
index f91cf6b42..000000000
--- a/bindings/Python/Generated/IR/LLVM/RoundAndCastToNearestLongOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::RoundAndCastToNearestLongOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1125]) || tp >= &(gTypes[1126])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::RoundAndCastToNearestLongOp::static_kind():
-      tp = &(gTypes[1125]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RoundAndCastToNearestLongOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongOp::value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundAndCastToNearestLongOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1125]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.RoundAndCastToNearestLongOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::RoundAndCastToNearestLongOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RoundAndCastToNearestLongOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RoundAndCastToNearestLongOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RoundAndCastToNearestLongOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/RoundToIntOp.cpp b/bindings/Python/Generated/IR/LLVM/RoundToIntOp.cpp
deleted file mode 100644
index fee30c3bb..000000000
--- a/bindings/Python/Generated/IR/LLVM/RoundToIntOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::RoundToIntOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1146]) || tp >= &(gTypes[1147])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::RoundToIntOp::static_kind():
-      tp = &(gTypes[1146]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RoundToIntOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToIntOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToIntOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToIntOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToIntOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToIntOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1146]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.RoundToIntOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::RoundToIntOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RoundToIntOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RoundToIntOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RoundToIntOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/RoundToNearbyIntOp.cpp b/bindings/Python/Generated/IR/LLVM/RoundToNearbyIntOp.cpp
deleted file mode 100644
index 96bc7c801..000000000
--- a/bindings/Python/Generated/IR/LLVM/RoundToNearbyIntOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::RoundToNearbyIntOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1140]) || tp >= &(gTypes[1141])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::RoundToNearbyIntOp::static_kind():
-      tp = &(gTypes[1140]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RoundToNearbyIntOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearbyIntOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearbyIntOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearbyIntOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearbyIntOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearbyIntOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1140]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.RoundToNearbyIntOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::RoundToNearbyIntOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RoundToNearbyIntOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RoundToNearbyIntOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RoundToNearbyIntOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/RoundToNearestEvenOp.cpp b/bindings/Python/Generated/IR/LLVM/RoundToNearestEvenOp.cpp
deleted file mode 100644
index 3ee7c1402..000000000
--- a/bindings/Python/Generated/IR/LLVM/RoundToNearestEvenOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::RoundToNearestEvenOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1147]) || tp >= &(gTypes[1148])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::RoundToNearestEvenOp::static_kind():
-      tp = &(gTypes[1147]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RoundToNearestEvenOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestEvenOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestEvenOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestEvenOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestEvenOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestEvenOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1147]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.RoundToNearestEvenOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::RoundToNearestEvenOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RoundToNearestEvenOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RoundToNearestEvenOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RoundToNearestEvenOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/RoundToNearestOp.cpp b/bindings/Python/Generated/IR/LLVM/RoundToNearestOp.cpp
deleted file mode 100644
index 858d0d2f5..000000000
--- a/bindings/Python/Generated/IR/LLVM/RoundToNearestOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::RoundToNearestOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1148]) || tp >= &(gTypes[1149])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::RoundToNearestOp::static_kind():
-      tp = &(gTypes[1148]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RoundToNearestOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::RoundToNearestOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1148]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.RoundToNearestOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::RoundToNearestOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RoundToNearestOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RoundToNearestOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RoundToNearestOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SAddSatOp.cpp b/bindings/Python/Generated/IR/LLVM/SAddSatOp.cpp
deleted file mode 100644
index 08c90c3cc..000000000
--- a/bindings/Python/Generated/IR/LLVM/SAddSatOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SAddSatOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1149]) || tp >= &(gTypes[1150])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SAddSatOp::static_kind():
-      tp = &(gTypes[1149]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SAddSatOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddSatOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddSatOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddSatOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddSatOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddSatOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddSatOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1149]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SAddSatOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SAddSatOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SAddSatOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SAddSatOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SAddSatOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SAddWithOverflowOp.cpp b/bindings/Python/Generated/IR/LLVM/SAddWithOverflowOp.cpp
deleted file mode 100644
index f01cc99c2..000000000
--- a/bindings/Python/Generated/IR/LLVM/SAddWithOverflowOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SAddWithOverflowOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1150]) || tp >= &(gTypes[1151])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SAddWithOverflowOp::static_kind():
-      tp = &(gTypes[1150]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SAddWithOverflowOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddWithOverflowOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddWithOverflowOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddWithOverflowOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SAddWithOverflowOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1150]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SAddWithOverflowOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SAddWithOverflowOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SAddWithOverflowOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SAddWithOverflowOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SAddWithOverflowOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SDivOp.cpp b/bindings/Python/Generated/IR/LLVM/SDivOp.cpp
deleted file mode 100644
index 594d93746..000000000
--- a/bindings/Python/Generated/IR/LLVM/SDivOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SDivOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1056]) || tp >= &(gTypes[1057])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SDivOp::static_kind():
-      tp = &(gTypes[1056]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SDivOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SDivOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SDivOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SDivOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SDivOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SDivOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SDivOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1056]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SDivOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SDivOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SDivOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SDivOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SDivOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SExtOp.cpp b/bindings/Python/Generated/IR/LLVM/SExtOp.cpp
deleted file mode 100644
index 6e2bad179..000000000
--- a/bindings/Python/Generated/IR/LLVM/SExtOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SExtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1057]) || tp >= &(gTypes[1058])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SExtOp::static_kind():
-      tp = &(gTypes[1057]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SExtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SExtOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SExtOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SExtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SExtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SExtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1057]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SExtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SExtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SExtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SExtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SExtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SIToFPOp.cpp b/bindings/Python/Generated/IR/LLVM/SIToFPOp.cpp
deleted file mode 100644
index 87160bdd3..000000000
--- a/bindings/Python/Generated/IR/LLVM/SIToFPOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SIToFPOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1058]) || tp >= &(gTypes[1059])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SIToFPOp::static_kind():
-      tp = &(gTypes[1058]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SIToFPOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SIToFPOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SIToFPOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SIToFPOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SIToFPOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SIToFPOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1058]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SIToFPOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SIToFPOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SIToFPOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SIToFPOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SIToFPOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SMaxOp.cpp b/bindings/Python/Generated/IR/LLVM/SMaxOp.cpp
deleted file mode 100644
index d020b164d..000000000
--- a/bindings/Python/Generated/IR/LLVM/SMaxOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SMaxOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1151]) || tp >= &(gTypes[1152])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SMaxOp::static_kind():
-      tp = &(gTypes[1151]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SMaxOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMaxOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMaxOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMaxOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMaxOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMaxOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMaxOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1151]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SMaxOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SMaxOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SMaxOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SMaxOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SMaxOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SMinOp.cpp b/bindings/Python/Generated/IR/LLVM/SMinOp.cpp
deleted file mode 100644
index ec74252e1..000000000
--- a/bindings/Python/Generated/IR/LLVM/SMinOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1152]) || tp >= &(gTypes[1153])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SMinOp::static_kind():
-      tp = &(gTypes[1152]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMinOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMinOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1152]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SMulWithOverflowOp.cpp b/bindings/Python/Generated/IR/LLVM/SMulWithOverflowOp.cpp
deleted file mode 100644
index 2b2e647b9..000000000
--- a/bindings/Python/Generated/IR/LLVM/SMulWithOverflowOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SMulWithOverflowOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1153]) || tp >= &(gTypes[1154])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SMulWithOverflowOp::static_kind():
-      tp = &(gTypes[1153]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SMulWithOverflowOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMulWithOverflowOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMulWithOverflowOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMulWithOverflowOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SMulWithOverflowOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1153]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SMulWithOverflowOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SMulWithOverflowOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SMulWithOverflowOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SMulWithOverflowOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SMulWithOverflowOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SRemOp.cpp b/bindings/Python/Generated/IR/LLVM/SRemOp.cpp
deleted file mode 100644
index 828c413b5..000000000
--- a/bindings/Python/Generated/IR/LLVM/SRemOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SRemOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1059]) || tp >= &(gTypes[1060])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SRemOp::static_kind():
-      tp = &(gTypes[1059]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SRemOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SRemOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SRemOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SRemOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SRemOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SRemOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SRemOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1059]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SRemOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SRemOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SRemOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SRemOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SRemOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SSACopyOp.cpp b/bindings/Python/Generated/IR/LLVM/SSACopyOp.cpp
deleted file mode 100644
index 51b4d2498..000000000
--- a/bindings/Python/Generated/IR/LLVM/SSACopyOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SSACopyOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1154]) || tp >= &(gTypes[1155])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SSACopyOp::static_kind():
-      tp = &(gTypes[1154]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SSACopyOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "operand",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->operand());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSACopyOp::operand"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSACopyOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSACopyOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSACopyOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSACopyOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1154]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SSACopyOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SSACopyOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SSACopyOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SSACopyOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SSACopyOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SShlSatOp.cpp b/bindings/Python/Generated/IR/LLVM/SShlSatOp.cpp
deleted file mode 100644
index cef6d0bee..000000000
--- a/bindings/Python/Generated/IR/LLVM/SShlSatOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SShlSatOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1155]) || tp >= &(gTypes[1156])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SShlSatOp::static_kind():
-      tp = &(gTypes[1155]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SShlSatOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SShlSatOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SShlSatOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SShlSatOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SShlSatOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SShlSatOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SShlSatOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1155]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SShlSatOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SShlSatOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SShlSatOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SShlSatOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SShlSatOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SSubSatOp.cpp b/bindings/Python/Generated/IR/LLVM/SSubSatOp.cpp
deleted file mode 100644
index bf955d9bf..000000000
--- a/bindings/Python/Generated/IR/LLVM/SSubSatOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SSubSatOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1156]) || tp >= &(gTypes[1157])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SSubSatOp::static_kind():
-      tp = &(gTypes[1156]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SSubSatOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubSatOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubSatOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubSatOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubSatOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubSatOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubSatOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1156]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SSubSatOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SSubSatOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SSubSatOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SSubSatOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SSubSatOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SSubWithOverflowOp.cpp b/bindings/Python/Generated/IR/LLVM/SSubWithOverflowOp.cpp
deleted file mode 100644
index 98754ce09..000000000
--- a/bindings/Python/Generated/IR/LLVM/SSubWithOverflowOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SSubWithOverflowOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1157]) || tp >= &(gTypes[1158])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SSubWithOverflowOp::static_kind():
-      tp = &(gTypes[1157]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SSubWithOverflowOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubWithOverflowOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubWithOverflowOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubWithOverflowOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SSubWithOverflowOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1157]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SSubWithOverflowOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SSubWithOverflowOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SSubWithOverflowOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SSubWithOverflowOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SSubWithOverflowOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ScalableVectorType.cpp b/bindings/Python/Generated/IR/LLVM/ScalableVectorType.cpp
deleted file mode 100644
index 01404111b..000000000
--- a/bindings/Python/Generated/IR/LLVM/ScalableVectorType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ScalableVectorType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1494]) || tp >= &(gTypes[1495])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ScalableVectorType::static_kind():
-      tp = &(gTypes[1494]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ScalableVectorType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "min_num_elements",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->min_num_elements());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ScalableVectorType::min_num_elements"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ScalableVectorType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ScalableVectorType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1494]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ScalableVectorType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ScalableVectorType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1489].tp_hash;
-  tp->tp_richcompare = gTypes[1489].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1489]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ScalableVectorType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ScalableVectorType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ScalableVectorType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SelectOp.cpp b/bindings/Python/Generated/IR/LLVM/SelectOp.cpp
deleted file mode 100644
index d6d19d1fc..000000000
--- a/bindings/Python/Generated/IR/LLVM/SelectOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SelectOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1060]) || tp >= &(gTypes[1061])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SelectOp::static_kind():
-      tp = &(gTypes[1060]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SelectOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "condition",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->condition());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SelectOp::condition"),
-    nullptr,
-  },
-  {
-    "true_value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->true_value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SelectOp::true_value"),
-    nullptr,
-  },
-  {
-    "false_value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->false_value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SelectOp::false_value"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SelectOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SelectOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SelectOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SelectOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1060]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SelectOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SelectOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SelectOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SelectOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SelectOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ShlOp.cpp b/bindings/Python/Generated/IR/LLVM/ShlOp.cpp
deleted file mode 100644
index b4024295c..000000000
--- a/bindings/Python/Generated/IR/LLVM/ShlOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ShlOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1061]) || tp >= &(gTypes[1062])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ShlOp::static_kind():
-      tp = &(gTypes[1061]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ShlOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShlOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShlOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShlOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShlOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShlOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShlOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1061]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ShlOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ShlOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ShlOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ShlOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ShlOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ShuffleVectorOp.cpp b/bindings/Python/Generated/IR/LLVM/ShuffleVectorOp.cpp
deleted file mode 100644
index 1c52e7f0e..000000000
--- a/bindings/Python/Generated/IR/LLVM/ShuffleVectorOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ShuffleVectorOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1062]) || tp >= &(gTypes[1063])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ShuffleVectorOp::static_kind():
-      tp = &(gTypes[1062]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ShuffleVectorOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "v1",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->v1());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShuffleVectorOp::v1"),
-    nullptr,
-  },
-  {
-    "v2",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->v2());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShuffleVectorOp::v2"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShuffleVectorOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShuffleVectorOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShuffleVectorOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ShuffleVectorOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1062]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ShuffleVectorOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ShuffleVectorOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ShuffleVectorOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ShuffleVectorOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ShuffleVectorOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SinOp.cpp b/bindings/Python/Generated/IR/LLVM/SinOp.cpp
deleted file mode 100644
index 6a446cfc1..000000000
--- a/bindings/Python/Generated/IR/LLVM/SinOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1158]) || tp >= &(gTypes[1159])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SinOp::static_kind():
-      tp = &(gTypes[1158]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SinOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1158]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SqrtOp.cpp b/bindings/Python/Generated/IR/LLVM/SqrtOp.cpp
deleted file mode 100644
index 610fa4a9e..000000000
--- a/bindings/Python/Generated/IR/LLVM/SqrtOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SqrtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1159]) || tp >= &(gTypes[1160])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SqrtOp::static_kind():
-      tp = &(gTypes[1159]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SqrtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SqrtOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SqrtOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SqrtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SqrtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SqrtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1159]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SqrtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SqrtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SqrtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SqrtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SqrtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/StackRestoreOp.cpp b/bindings/Python/Generated/IR/LLVM/StackRestoreOp.cpp
deleted file mode 100644
index 7859f67e9..000000000
--- a/bindings/Python/Generated/IR/LLVM/StackRestoreOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::StackRestoreOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1160]) || tp >= &(gTypes[1161])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::StackRestoreOp::static_kind():
-      tp = &(gTypes[1160]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StackRestoreOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StackRestoreOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StackRestoreOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StackRestoreOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1160]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.StackRestoreOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::StackRestoreOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StackRestoreOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StackRestoreOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StackRestoreOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/StackSaveOp.cpp b/bindings/Python/Generated/IR/LLVM/StackSaveOp.cpp
deleted file mode 100644
index cfa20540e..000000000
--- a/bindings/Python/Generated/IR/LLVM/StackSaveOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::StackSaveOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1161]) || tp >= &(gTypes[1162])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::StackSaveOp::static_kind():
-      tp = &(gTypes[1161]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StackSaveOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StackSaveOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StackSaveOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StackSaveOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StackSaveOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1161]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.StackSaveOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::StackSaveOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StackSaveOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StackSaveOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StackSaveOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/StepVectorOp.cpp b/bindings/Python/Generated/IR/LLVM/StepVectorOp.cpp
deleted file mode 100644
index 9da350c07..000000000
--- a/bindings/Python/Generated/IR/LLVM/StepVectorOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::StepVectorOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1162]) || tp >= &(gTypes[1163])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::StepVectorOp::static_kind():
-      tp = &(gTypes[1162]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StepVectorOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StepVectorOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StepVectorOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StepVectorOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StepVectorOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1162]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.StepVectorOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::StepVectorOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StepVectorOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StepVectorOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StepVectorOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/StoreOp.cpp b/bindings/Python/Generated/IR/LLVM/StoreOp.cpp
deleted file mode 100644
index ce26eea37..000000000
--- a/bindings/Python/Generated/IR/LLVM/StoreOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::StoreOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1063]) || tp >= &(gTypes[1064])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::StoreOp::static_kind():
-      tp = &(gTypes[1063]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StoreOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StoreOp::value"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StoreOp::alignment"),
-    nullptr,
-  },
-  {
-    "volatile__",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->volatile__());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StoreOp::volatile__"),
-    nullptr,
-  },
-  {
-    "nontemporal",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->nontemporal());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StoreOp::nontemporal"),
-    nullptr,
-  },
-  {
-    "syncscope",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->syncscope());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StoreOp::syncscope"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StoreOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StoreOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::StoreOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1063]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.StoreOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::StoreOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StoreOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StoreOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StoreOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SubOp.cpp b/bindings/Python/Generated/IR/LLVM/SubOp.cpp
deleted file mode 100644
index d53cf32ab..000000000
--- a/bindings/Python/Generated/IR/LLVM/SubOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SubOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1064]) || tp >= &(gTypes[1065])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SubOp::static_kind():
-      tp = &(gTypes[1064]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SubOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SubOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SubOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SubOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SubOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SubOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SubOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1064]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SubOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SubOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SubOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SubOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SubOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/SwitchOp.cpp b/bindings/Python/Generated/IR/LLVM/SwitchOp.cpp
deleted file mode 100644
index 9047f5acf..000000000
--- a/bindings/Python/Generated/IR/LLVM/SwitchOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::SwitchOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1065]) || tp >= &(gTypes[1066])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::SwitchOp::static_kind():
-      tp = &(gTypes[1065]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SwitchOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "default_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::default_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SwitchOp::default_operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SwitchOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SwitchOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::SwitchOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1065]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.SwitchOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::SwitchOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SwitchOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SwitchOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SwitchOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/TBAAMemberAttr.cpp b/bindings/Python/Generated/IR/LLVM/TBAAMemberAttr.cpp
deleted file mode 100644
index f0eb823ee..000000000
--- a/bindings/Python/Generated/IR/LLVM/TBAAMemberAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::TBAAMemberAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[931]) || tp >= &(gTypes[932])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::TBAAMemberAttr::static_kind():
-      tp = &(gTypes[931]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TBAAMemberAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "offset",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->offset());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAAMemberAttr::offset"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAAMemberAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAAMemberAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[931]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.TBAAMemberAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::TBAAMemberAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TBAAMemberAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TBAAMemberAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TBAAMemberAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/TBAARootAttr.cpp b/bindings/Python/Generated/IR/LLVM/TBAARootAttr.cpp
deleted file mode 100644
index eb78bdc82..000000000
--- a/bindings/Python/Generated/IR/LLVM/TBAARootAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::TBAARootAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[930]) || tp >= &(gTypes[931])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::TBAARootAttr::static_kind():
-      tp = &(gTypes[930]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TBAARootAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAARootAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAARootAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[930]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.TBAARootAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::TBAARootAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TBAARootAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TBAARootAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TBAARootAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/TBAATagAttr.cpp b/bindings/Python/Generated/IR/LLVM/TBAATagAttr.cpp
deleted file mode 100644
index 096ab3581..000000000
--- a/bindings/Python/Generated/IR/LLVM/TBAATagAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::TBAATagAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[933]) || tp >= &(gTypes[934])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::TBAATagAttr::static_kind():
-      tp = &(gTypes[933]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TBAATagAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "offset",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->offset());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAATagAttr::offset"),
-    nullptr,
-  },
-  {
-    "constant",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->constant());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAATagAttr::constant"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAATagAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAATagAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[933]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.TBAATagAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::TBAATagAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TBAATagAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TBAATagAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TBAATagAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/TBAATypeDescriptorAttr.cpp b/bindings/Python/Generated/IR/LLVM/TBAATypeDescriptorAttr.cpp
deleted file mode 100644
index e38dea5b7..000000000
--- a/bindings/Python/Generated/IR/LLVM/TBAATypeDescriptorAttr.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::TBAATypeDescriptorAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[932]) || tp >= &(gTypes[933])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::TBAATypeDescriptorAttr::static_kind():
-      tp = &(gTypes[932]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TBAATypeDescriptorAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "id",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->id());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAATypeDescriptorAttr::id"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAATypeDescriptorAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TBAATypeDescriptorAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[932]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.TBAATypeDescriptorAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::TBAATypeDescriptorAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TBAATypeDescriptorAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TBAATypeDescriptorAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TBAATypeDescriptorAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/TargetExtType.cpp b/bindings/Python/Generated/IR/LLVM/TargetExtType.cpp
deleted file mode 100644
index 5df484eed..000000000
--- a/bindings/Python/Generated/IR/LLVM/TargetExtType.cpp
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::TargetExtType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1495]) || tp >= &(gTypes[1496])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::TargetExtType::static_kind():
-      tp = &(gTypes[1495]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TargetExtType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "supports_mem_ops",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->supports_mem_ops());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TargetExtType::supports_mem_ops"),
-    nullptr,
-  },
-  {
-    "ext_type_name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->ext_type_name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TargetExtType::ext_type_name"),
-    nullptr,
-  },
-  {
-    "type_params",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::type_params);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TargetExtType::type_params"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TargetExtType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TargetExtType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1495]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.TargetExtType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::TargetExtType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1489].tp_hash;
-  tp->tp_richcompare = gTypes[1489].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1489]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TargetExtType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TargetExtType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TargetExtType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/TargetFeaturesAttr.cpp b/bindings/Python/Generated/IR/LLVM/TargetFeaturesAttr.cpp
deleted file mode 100644
index fd3ed7252..000000000
--- a/bindings/Python/Generated/IR/LLVM/TargetFeaturesAttr.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::TargetFeaturesAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[935]) || tp >= &(gTypes[936])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::TargetFeaturesAttr::static_kind():
-      tp = &(gTypes[935]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TargetFeaturesAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "null_or_empty",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->null_or_empty());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TargetFeaturesAttr::null_or_empty"),
-    nullptr,
-  },
-  {
-    "features_string",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->features_string());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TargetFeaturesAttr::features_string"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TargetFeaturesAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TargetFeaturesAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[935]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.TargetFeaturesAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::TargetFeaturesAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TargetFeaturesAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TargetFeaturesAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TargetFeaturesAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ThreadLocalAddressOp.cpp b/bindings/Python/Generated/IR/LLVM/ThreadLocalAddressOp.cpp
deleted file mode 100644
index d9f2be7b9..000000000
--- a/bindings/Python/Generated/IR/LLVM/ThreadLocalAddressOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ThreadLocalAddressOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1163]) || tp >= &(gTypes[1164])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ThreadLocalAddressOp::static_kind():
-      tp = &(gTypes[1163]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ThreadLocalAddressOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ThreadLocalAddressOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ThreadLocalAddressOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ThreadLocalAddressOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ThreadLocalAddressOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1163]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ThreadLocalAddressOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ThreadLocalAddressOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ThreadLocalAddressOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ThreadLocalAddressOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ThreadLocalAddressOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/TrapOp.cpp b/bindings/Python/Generated/IR/LLVM/TrapOp.cpp
deleted file mode 100644
index 66d49cb6d..000000000
--- a/bindings/Python/Generated/IR/LLVM/TrapOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::TrapOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1164]) || tp >= &(gTypes[1165])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::TrapOp::static_kind():
-      tp = &(gTypes[1164]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TrapOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TrapOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TrapOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TrapOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1164]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.TrapOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::TrapOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TrapOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TrapOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TrapOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/TruncOp.cpp b/bindings/Python/Generated/IR/LLVM/TruncOp.cpp
deleted file mode 100644
index 81a70d35b..000000000
--- a/bindings/Python/Generated/IR/LLVM/TruncOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::TruncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1066]) || tp >= &(gTypes[1067])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::TruncOp::static_kind():
-      tp = &(gTypes[1066]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TruncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TruncOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TruncOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TruncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TruncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::TruncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1066]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.TruncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::TruncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TruncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TruncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TruncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/Type.cpp b/bindings/Python/Generated/IR/LLVM/Type.cpp
deleted file mode 100644
index 3b338842d..000000000
--- a/bindings/Python/Generated/IR/LLVM/Type.cpp
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1489]) || tp >= &(gTypes[1496])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ArrayType::static_kind():
-      tp = &(gTypes[1490]);
-      break;
-
-    case mx::ir::llvm::FunctionType::static_kind():
-      tp = &(gTypes[1491]);
-      break;
-
-    case mx::ir::llvm::PointerType::static_kind():
-      tp = &(gTypes[1492]);
-      break;
-
-    case mx::ir::llvm::FixedVectorType::static_kind():
-      tp = &(gTypes[1493]);
-      break;
-
-    case mx::ir::llvm::ScalableVectorType::static_kind():
-      tp = &(gTypes[1494]);
-      break;
-
-    case mx::ir::llvm::TargetExtType::static_kind():
-      tp = &(gTypes[1495]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1489]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1461].tp_hash;
-  tp->tp_richcompare = gTypes[1461].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1461]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UAddSatOp.cpp b/bindings/Python/Generated/IR/LLVM/UAddSatOp.cpp
deleted file mode 100644
index 703a285bb..000000000
--- a/bindings/Python/Generated/IR/LLVM/UAddSatOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UAddSatOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1165]) || tp >= &(gTypes[1166])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UAddSatOp::static_kind():
-      tp = &(gTypes[1165]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UAddSatOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddSatOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddSatOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddSatOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddSatOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddSatOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddSatOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1165]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UAddSatOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UAddSatOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UAddSatOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UAddSatOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UAddSatOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UAddWithOverflowOp.cpp b/bindings/Python/Generated/IR/LLVM/UAddWithOverflowOp.cpp
deleted file mode 100644
index a64e72ed5..000000000
--- a/bindings/Python/Generated/IR/LLVM/UAddWithOverflowOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UAddWithOverflowOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1166]) || tp >= &(gTypes[1167])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UAddWithOverflowOp::static_kind():
-      tp = &(gTypes[1166]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UAddWithOverflowOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddWithOverflowOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddWithOverflowOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddWithOverflowOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UAddWithOverflowOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1166]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UAddWithOverflowOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UAddWithOverflowOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UAddWithOverflowOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UAddWithOverflowOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UAddWithOverflowOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UBSanTrapOp.cpp b/bindings/Python/Generated/IR/LLVM/UBSanTrapOp.cpp
deleted file mode 100644
index 8c0baa382..000000000
--- a/bindings/Python/Generated/IR/LLVM/UBSanTrapOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UBSanTrapOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1167]) || tp >= &(gTypes[1168])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UBSanTrapOp::static_kind():
-      tp = &(gTypes[1167]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UBSanTrapOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "failure_kind",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->failure_kind());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UBSanTrapOp::failure_kind"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UBSanTrapOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UBSanTrapOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UBSanTrapOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1167]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UBSanTrapOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UBSanTrapOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UBSanTrapOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UBSanTrapOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UBSanTrapOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UDivOp.cpp b/bindings/Python/Generated/IR/LLVM/UDivOp.cpp
deleted file mode 100644
index c949e181c..000000000
--- a/bindings/Python/Generated/IR/LLVM/UDivOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UDivOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1067]) || tp >= &(gTypes[1068])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UDivOp::static_kind():
-      tp = &(gTypes[1067]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UDivOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UDivOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UDivOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UDivOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UDivOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UDivOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UDivOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1067]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UDivOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UDivOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UDivOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UDivOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UDivOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UIToFPOp.cpp b/bindings/Python/Generated/IR/LLVM/UIToFPOp.cpp
deleted file mode 100644
index 5a44d245f..000000000
--- a/bindings/Python/Generated/IR/LLVM/UIToFPOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UIToFPOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1068]) || tp >= &(gTypes[1069])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UIToFPOp::static_kind():
-      tp = &(gTypes[1068]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UIToFPOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UIToFPOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UIToFPOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UIToFPOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UIToFPOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UIToFPOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1068]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UIToFPOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UIToFPOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UIToFPOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UIToFPOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UIToFPOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UMaxOp.cpp b/bindings/Python/Generated/IR/LLVM/UMaxOp.cpp
deleted file mode 100644
index eff5a9749..000000000
--- a/bindings/Python/Generated/IR/LLVM/UMaxOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UMaxOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1168]) || tp >= &(gTypes[1169])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UMaxOp::static_kind():
-      tp = &(gTypes[1168]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UMaxOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMaxOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMaxOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMaxOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMaxOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMaxOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMaxOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1168]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UMaxOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UMaxOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UMaxOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UMaxOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UMaxOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UMinOp.cpp b/bindings/Python/Generated/IR/LLVM/UMinOp.cpp
deleted file mode 100644
index 4202a4eae..000000000
--- a/bindings/Python/Generated/IR/LLVM/UMinOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1169]) || tp >= &(gTypes[1170])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UMinOp::static_kind():
-      tp = &(gTypes[1169]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMinOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMinOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1169]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UMulWithOverflowOp.cpp b/bindings/Python/Generated/IR/LLVM/UMulWithOverflowOp.cpp
deleted file mode 100644
index b682d6ad3..000000000
--- a/bindings/Python/Generated/IR/LLVM/UMulWithOverflowOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UMulWithOverflowOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1170]) || tp >= &(gTypes[1171])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UMulWithOverflowOp::static_kind():
-      tp = &(gTypes[1170]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UMulWithOverflowOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMulWithOverflowOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMulWithOverflowOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMulWithOverflowOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UMulWithOverflowOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1170]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UMulWithOverflowOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UMulWithOverflowOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UMulWithOverflowOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UMulWithOverflowOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UMulWithOverflowOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/URemOp.cpp b/bindings/Python/Generated/IR/LLVM/URemOp.cpp
deleted file mode 100644
index 814a4a60d..000000000
--- a/bindings/Python/Generated/IR/LLVM/URemOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::URemOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1069]) || tp >= &(gTypes[1070])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::URemOp::static_kind():
-      tp = &(gTypes[1069]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "URemOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::URemOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::URemOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::URemOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::URemOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::URemOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::URemOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1069]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.URemOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::URemOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'URemOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'URemOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'URemOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UShlSatOp.cpp b/bindings/Python/Generated/IR/LLVM/UShlSatOp.cpp
deleted file mode 100644
index 9f910d9c7..000000000
--- a/bindings/Python/Generated/IR/LLVM/UShlSatOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UShlSatOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1171]) || tp >= &(gTypes[1172])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UShlSatOp::static_kind():
-      tp = &(gTypes[1171]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UShlSatOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UShlSatOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UShlSatOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UShlSatOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UShlSatOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UShlSatOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UShlSatOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1171]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UShlSatOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UShlSatOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UShlSatOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UShlSatOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UShlSatOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/USubSatOp.cpp b/bindings/Python/Generated/IR/LLVM/USubSatOp.cpp
deleted file mode 100644
index 56d43d85a..000000000
--- a/bindings/Python/Generated/IR/LLVM/USubSatOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::USubSatOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1172]) || tp >= &(gTypes[1173])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::USubSatOp::static_kind():
-      tp = &(gTypes[1172]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "USubSatOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "a",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->a());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubSatOp::a"),
-    nullptr,
-  },
-  {
-    "b",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->b());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubSatOp::b"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubSatOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubSatOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubSatOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubSatOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1172]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.USubSatOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::USubSatOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'USubSatOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'USubSatOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'USubSatOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/USubWithOverflowOp.cpp b/bindings/Python/Generated/IR/LLVM/USubWithOverflowOp.cpp
deleted file mode 100644
index 47597c1b8..000000000
--- a/bindings/Python/Generated/IR/LLVM/USubWithOverflowOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::USubWithOverflowOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1173]) || tp >= &(gTypes[1174])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::USubWithOverflowOp::static_kind():
-      tp = &(gTypes[1173]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "USubWithOverflowOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubWithOverflowOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubWithOverflowOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubWithOverflowOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::USubWithOverflowOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1173]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.USubWithOverflowOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::USubWithOverflowOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'USubWithOverflowOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'USubWithOverflowOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'USubWithOverflowOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UndefOp.cpp b/bindings/Python/Generated/IR/LLVM/UndefOp.cpp
deleted file mode 100644
index 253e8e439..000000000
--- a/bindings/Python/Generated/IR/LLVM/UndefOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UndefOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1070]) || tp >= &(gTypes[1071])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UndefOp::static_kind():
-      tp = &(gTypes[1070]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UndefOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UndefOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UndefOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UndefOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UndefOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1070]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UndefOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UndefOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UndefOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UndefOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UndefOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/UnreachableOp.cpp b/bindings/Python/Generated/IR/LLVM/UnreachableOp.cpp
deleted file mode 100644
index 128a7c9b2..000000000
--- a/bindings/Python/Generated/IR/LLVM/UnreachableOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::UnreachableOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1071]) || tp >= &(gTypes[1072])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::UnreachableOp::static_kind():
-      tp = &(gTypes[1071]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnreachableOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UnreachableOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UnreachableOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::UnreachableOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1071]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.UnreachableOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::UnreachableOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnreachableOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnreachableOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnreachableOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPAShrOp.cpp b/bindings/Python/Generated/IR/LLVM/VPAShrOp.cpp
deleted file mode 100644
index 34d5e7826..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPAShrOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPAShrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1174]) || tp >= &(gTypes[1175])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPAShrOp::static_kind():
-      tp = &(gTypes[1174]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPAShrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAShrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAShrOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAShrOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAShrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAShrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAShrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAShrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1174]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPAShrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPAShrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPAShrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPAShrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPAShrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPAddOp.cpp b/bindings/Python/Generated/IR/LLVM/VPAddOp.cpp
deleted file mode 100644
index 241edac4d..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPAddOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPAddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1175]) || tp >= &(gTypes[1176])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPAddOp::static_kind():
-      tp = &(gTypes[1175]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPAddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAddOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAddOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAddOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1175]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPAddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPAddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPAddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPAddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPAddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPAndOp.cpp b/bindings/Python/Generated/IR/LLVM/VPAndOp.cpp
deleted file mode 100644
index 1a208cbdb..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPAndOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPAndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1176]) || tp >= &(gTypes[1177])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPAndOp::static_kind():
-      tp = &(gTypes[1176]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPAndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAndOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAndOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAndOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAndOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPAndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1176]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPAndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPAndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPAndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPAndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPAndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFAddOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFAddOp.cpp
deleted file mode 100644
index b21365055..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFAddOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFAddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1177]) || tp >= &(gTypes[1178])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFAddOp::static_kind():
-      tp = &(gTypes[1177]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFAddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFAddOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFAddOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFAddOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFAddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFAddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFAddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFAddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1177]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFAddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFAddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFAddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFAddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFAddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFDivOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFDivOp.cpp
deleted file mode 100644
index 86ee842d4..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFDivOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFDivOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1178]) || tp >= &(gTypes[1179])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFDivOp::static_kind():
-      tp = &(gTypes[1178]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFDivOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFDivOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFDivOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFDivOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFDivOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFDivOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFDivOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFDivOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1178]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFDivOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFDivOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFDivOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFDivOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFDivOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFMulAddOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFMulAddOp.cpp
deleted file mode 100644
index 6ed5b959d..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFMulAddOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFMulAddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1179]) || tp >= &(gTypes[1180])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFMulAddOp::static_kind():
-      tp = &(gTypes[1179]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFMulAddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "op1",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->op1());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulAddOp::op1"),
-    nullptr,
-  },
-  {
-    "op2",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->op2());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulAddOp::op2"),
-    nullptr,
-  },
-  {
-    "op3",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->op3());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulAddOp::op3"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulAddOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulAddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulAddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulAddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulAddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1179]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFMulAddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFMulAddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFMulAddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFMulAddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFMulAddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFMulOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFMulOp.cpp
deleted file mode 100644
index c3d84bb8f..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFMulOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFMulOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1180]) || tp >= &(gTypes[1181])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFMulOp::static_kind():
-      tp = &(gTypes[1180]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFMulOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFMulOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1180]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFMulOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFMulOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFMulOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFMulOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFMulOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFNegOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFNegOp.cpp
deleted file mode 100644
index 1a86bfb0c..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFNegOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFNegOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1181]) || tp >= &(gTypes[1182])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFNegOp::static_kind():
-      tp = &(gTypes[1181]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFNegOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "op",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->op());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFNegOp::op"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFNegOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFNegOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFNegOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFNegOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFNegOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1181]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFNegOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFNegOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFNegOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFNegOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFNegOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFPExtOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFPExtOp.cpp
deleted file mode 100644
index 3b8b2aa5b..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFPExtOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFPExtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1182]) || tp >= &(gTypes[1183])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFPExtOp::static_kind():
-      tp = &(gTypes[1182]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFPExtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPExtOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPExtOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPExtOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPExtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPExtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPExtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1182]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFPExtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFPExtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFPExtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFPExtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFPExtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFPToSIOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFPToSIOp.cpp
deleted file mode 100644
index 4a1e79018..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFPToSIOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFPToSIOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1183]) || tp >= &(gTypes[1184])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFPToSIOp::static_kind():
-      tp = &(gTypes[1183]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFPToSIOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToSIOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToSIOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToSIOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToSIOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToSIOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToSIOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1183]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFPToSIOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFPToSIOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFPToSIOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFPToSIOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFPToSIOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFPToUIOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFPToUIOp.cpp
deleted file mode 100644
index c2bb6c6ce..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFPToUIOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFPToUIOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1184]) || tp >= &(gTypes[1185])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFPToUIOp::static_kind():
-      tp = &(gTypes[1184]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFPToUIOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToUIOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToUIOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToUIOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToUIOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToUIOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPToUIOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1184]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFPToUIOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFPToUIOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFPToUIOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFPToUIOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFPToUIOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFPTruncOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFPTruncOp.cpp
deleted file mode 100644
index 7dc9836a6..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFPTruncOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFPTruncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1185]) || tp >= &(gTypes[1186])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFPTruncOp::static_kind():
-      tp = &(gTypes[1185]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFPTruncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPTruncOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPTruncOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPTruncOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPTruncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPTruncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFPTruncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1185]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFPTruncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFPTruncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFPTruncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFPTruncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFPTruncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFRemOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFRemOp.cpp
deleted file mode 100644
index 51a15e5ca..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFRemOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFRemOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1186]) || tp >= &(gTypes[1187])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFRemOp::static_kind():
-      tp = &(gTypes[1186]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFRemOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFRemOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFRemOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFRemOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFRemOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFRemOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFRemOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFRemOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1186]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFRemOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFRemOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFRemOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFRemOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFRemOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFSubOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFSubOp.cpp
deleted file mode 100644
index 801352b40..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFSubOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFSubOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1187]) || tp >= &(gTypes[1188])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFSubOp::static_kind():
-      tp = &(gTypes[1187]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFSubOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFSubOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFSubOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFSubOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFSubOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFSubOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFSubOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFSubOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1187]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFSubOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFSubOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFSubOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFSubOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFSubOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPFmaOp.cpp b/bindings/Python/Generated/IR/LLVM/VPFmaOp.cpp
deleted file mode 100644
index b803ac768..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPFmaOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPFmaOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1188]) || tp >= &(gTypes[1189])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPFmaOp::static_kind():
-      tp = &(gTypes[1188]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPFmaOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "op1",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->op1());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFmaOp::op1"),
-    nullptr,
-  },
-  {
-    "op2",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->op2());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFmaOp::op2"),
-    nullptr,
-  },
-  {
-    "op3",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->op3());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFmaOp::op3"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFmaOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFmaOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFmaOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFmaOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPFmaOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1188]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPFmaOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPFmaOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPFmaOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPFmaOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPFmaOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPIntToPtrOp.cpp b/bindings/Python/Generated/IR/LLVM/VPIntToPtrOp.cpp
deleted file mode 100644
index d3fe834ab..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPIntToPtrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPIntToPtrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1189]) || tp >= &(gTypes[1190])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPIntToPtrOp::static_kind():
-      tp = &(gTypes[1189]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPIntToPtrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPIntToPtrOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPIntToPtrOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPIntToPtrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPIntToPtrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPIntToPtrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPIntToPtrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1189]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPIntToPtrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPIntToPtrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPIntToPtrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPIntToPtrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPIntToPtrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPLShrOp.cpp b/bindings/Python/Generated/IR/LLVM/VPLShrOp.cpp
deleted file mode 100644
index ae90a9ded..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPLShrOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPLShrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1190]) || tp >= &(gTypes[1191])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPLShrOp::static_kind():
-      tp = &(gTypes[1190]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPLShrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLShrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLShrOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLShrOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLShrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLShrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLShrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLShrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1190]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPLShrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPLShrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPLShrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPLShrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPLShrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPLoadOp.cpp b/bindings/Python/Generated/IR/LLVM/VPLoadOp.cpp
deleted file mode 100644
index cb8743ee4..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPLoadOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPLoadOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1191]) || tp >= &(gTypes[1192])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPLoadOp::static_kind():
-      tp = &(gTypes[1191]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPLoadOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLoadOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLoadOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLoadOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLoadOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPLoadOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1191]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPLoadOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPLoadOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPLoadOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPLoadOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPLoadOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPMergeMinOp.cpp b/bindings/Python/Generated/IR/LLVM/VPMergeMinOp.cpp
deleted file mode 100644
index 0a5c0a169..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPMergeMinOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPMergeMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1192]) || tp >= &(gTypes[1193])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPMergeMinOp::static_kind():
-      tp = &(gTypes[1192]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPMergeMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "cond",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->cond());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMergeMinOp::cond"),
-    nullptr,
-  },
-  {
-    "true_val",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->true_val());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMergeMinOp::true_val"),
-    nullptr,
-  },
-  {
-    "false_val",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->false_val());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMergeMinOp::false_val"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMergeMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMergeMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMergeMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMergeMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1192]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPMergeMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPMergeMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPMergeMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPMergeMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPMergeMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPMulOp.cpp b/bindings/Python/Generated/IR/LLVM/VPMulOp.cpp
deleted file mode 100644
index fdd3252b9..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPMulOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPMulOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1193]) || tp >= &(gTypes[1194])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPMulOp::static_kind():
-      tp = &(gTypes[1193]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPMulOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMulOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMulOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMulOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMulOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMulOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMulOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPMulOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1193]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPMulOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPMulOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPMulOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPMulOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPMulOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPOrOp.cpp b/bindings/Python/Generated/IR/LLVM/VPOrOp.cpp
deleted file mode 100644
index 3d4c89058..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPOrOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPOrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1194]) || tp >= &(gTypes[1195])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPOrOp::static_kind():
-      tp = &(gTypes[1194]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPOrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPOrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPOrOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPOrOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPOrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPOrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPOrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPOrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1194]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPOrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPOrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPOrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPOrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPOrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPPtrToIntOp.cpp b/bindings/Python/Generated/IR/LLVM/VPPtrToIntOp.cpp
deleted file mode 100644
index be2702ccc..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPPtrToIntOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPPtrToIntOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1195]) || tp >= &(gTypes[1196])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPPtrToIntOp::static_kind():
-      tp = &(gTypes[1195]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPPtrToIntOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPPtrToIntOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPPtrToIntOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPPtrToIntOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPPtrToIntOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPPtrToIntOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPPtrToIntOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1195]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPPtrToIntOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPPtrToIntOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPPtrToIntOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPPtrToIntOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPPtrToIntOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceAddOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceAddOp.cpp
deleted file mode 100644
index 72ee8838f..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceAddOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceAddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1196]) || tp >= &(gTypes[1197])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceAddOp::static_kind():
-      tp = &(gTypes[1196]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceAddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAddOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAddOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1196]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceAddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceAddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceAddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceAddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceAddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceAndOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceAndOp.cpp
deleted file mode 100644
index 5f5f944fc..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceAndOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceAndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1197]) || tp >= &(gTypes[1198])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceAndOp::static_kind():
-      tp = &(gTypes[1197]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceAndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAndOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAndOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAndOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceAndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1197]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceAndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceAndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceAndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceAndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceAndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceFAddOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceFAddOp.cpp
deleted file mode 100644
index 3429d3701..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceFAddOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceFAddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1198]) || tp >= &(gTypes[1199])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceFAddOp::static_kind():
-      tp = &(gTypes[1198]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceFAddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFAddOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFAddOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFAddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFAddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFAddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFAddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1198]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceFAddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceFAddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceFAddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceFAddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceFAddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceFMaxOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceFMaxOp.cpp
deleted file mode 100644
index 277fada38..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceFMaxOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceFMaxOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1199]) || tp >= &(gTypes[1200])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceFMaxOp::static_kind():
-      tp = &(gTypes[1199]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceFMaxOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMaxOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMaxOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMaxOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMaxOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMaxOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMaxOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1199]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceFMaxOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceFMaxOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceFMaxOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceFMaxOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceFMaxOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceFMinOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceFMinOp.cpp
deleted file mode 100644
index 67cc08347..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceFMinOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceFMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1200]) || tp >= &(gTypes[1201])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceFMinOp::static_kind():
-      tp = &(gTypes[1200]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceFMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMinOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMinOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1200]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceFMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceFMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceFMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceFMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceFMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceFMulOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceFMulOp.cpp
deleted file mode 100644
index a3992221a..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceFMulOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceFMulOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1201]) || tp >= &(gTypes[1202])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceFMulOp::static_kind():
-      tp = &(gTypes[1201]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceFMulOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMulOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMulOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMulOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMulOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMulOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceFMulOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1201]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceFMulOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceFMulOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceFMulOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceFMulOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceFMulOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceMulOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceMulOp.cpp
deleted file mode 100644
index 066505e4e..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceMulOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceMulOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1202]) || tp >= &(gTypes[1203])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceMulOp::static_kind():
-      tp = &(gTypes[1202]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceMulOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceMulOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceMulOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceMulOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceMulOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceMulOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceMulOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1202]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceMulOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceMulOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceMulOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceMulOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceMulOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceOrOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceOrOp.cpp
deleted file mode 100644
index 446201c5f..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceOrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceOrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1203]) || tp >= &(gTypes[1204])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceOrOp::static_kind():
-      tp = &(gTypes[1203]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceOrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceOrOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceOrOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceOrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceOrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceOrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceOrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1203]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceOrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceOrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceOrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceOrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceOrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceSMaxOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceSMaxOp.cpp
deleted file mode 100644
index 31a236375..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceSMaxOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceSMaxOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1204]) || tp >= &(gTypes[1205])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceSMaxOp::static_kind():
-      tp = &(gTypes[1204]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceSMaxOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMaxOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMaxOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMaxOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMaxOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMaxOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMaxOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1204]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceSMaxOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceSMaxOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceSMaxOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceSMaxOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceSMaxOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceSMinOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceSMinOp.cpp
deleted file mode 100644
index 535b8e3e0..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceSMinOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceSMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1205]) || tp >= &(gTypes[1206])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceSMinOp::static_kind():
-      tp = &(gTypes[1205]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceSMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMinOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMinOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceSMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1205]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceSMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceSMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceSMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceSMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceSMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceUMaxOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceUMaxOp.cpp
deleted file mode 100644
index 22797eead..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceUMaxOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceUMaxOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1206]) || tp >= &(gTypes[1207])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceUMaxOp::static_kind():
-      tp = &(gTypes[1206]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceUMaxOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMaxOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMaxOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMaxOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMaxOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMaxOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMaxOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1206]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceUMaxOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceUMaxOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceUMaxOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceUMaxOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceUMaxOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceUMinOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceUMinOp.cpp
deleted file mode 100644
index e5a6972cf..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceUMinOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceUMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1207]) || tp >= &(gTypes[1208])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceUMinOp::static_kind():
-      tp = &(gTypes[1207]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceUMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMinOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMinOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceUMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1207]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceUMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceUMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceUMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceUMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceUMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPReduceXorOp.cpp b/bindings/Python/Generated/IR/LLVM/VPReduceXorOp.cpp
deleted file mode 100644
index 3c99b918a..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPReduceXorOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPReduceXorOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1208]) || tp >= &(gTypes[1209])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPReduceXorOp::static_kind():
-      tp = &(gTypes[1208]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPReduceXorOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceXorOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceXorOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceXorOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceXorOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceXorOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPReduceXorOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1208]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPReduceXorOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPReduceXorOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPReduceXorOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPReduceXorOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPReduceXorOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPSDivOp.cpp b/bindings/Python/Generated/IR/LLVM/VPSDivOp.cpp
deleted file mode 100644
index c34c0d530..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPSDivOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPSDivOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1209]) || tp >= &(gTypes[1210])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPSDivOp::static_kind():
-      tp = &(gTypes[1209]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPSDivOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSDivOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSDivOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSDivOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSDivOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSDivOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSDivOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSDivOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1209]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPSDivOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPSDivOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPSDivOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPSDivOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPSDivOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPSExtOp.cpp b/bindings/Python/Generated/IR/LLVM/VPSExtOp.cpp
deleted file mode 100644
index 832bd8cb6..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPSExtOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPSExtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1210]) || tp >= &(gTypes[1211])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPSExtOp::static_kind():
-      tp = &(gTypes[1210]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPSExtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSExtOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSExtOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSExtOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSExtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSExtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSExtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1210]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPSExtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPSExtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPSExtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPSExtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPSExtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPSIToFPOp.cpp b/bindings/Python/Generated/IR/LLVM/VPSIToFPOp.cpp
deleted file mode 100644
index db7e908e1..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPSIToFPOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPSIToFPOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1211]) || tp >= &(gTypes[1212])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPSIToFPOp::static_kind():
-      tp = &(gTypes[1211]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPSIToFPOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSIToFPOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSIToFPOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSIToFPOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSIToFPOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSIToFPOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSIToFPOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1211]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPSIToFPOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPSIToFPOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPSIToFPOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPSIToFPOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPSIToFPOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPSRemOp.cpp b/bindings/Python/Generated/IR/LLVM/VPSRemOp.cpp
deleted file mode 100644
index 27470d02d..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPSRemOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPSRemOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1212]) || tp >= &(gTypes[1213])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPSRemOp::static_kind():
-      tp = &(gTypes[1212]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPSRemOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSRemOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSRemOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSRemOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSRemOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSRemOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSRemOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSRemOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1212]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPSRemOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPSRemOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPSRemOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPSRemOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPSRemOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPSelectMinOp.cpp b/bindings/Python/Generated/IR/LLVM/VPSelectMinOp.cpp
deleted file mode 100644
index 1a23c9910..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPSelectMinOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPSelectMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1213]) || tp >= &(gTypes[1214])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPSelectMinOp::static_kind():
-      tp = &(gTypes[1213]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPSelectMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "cond",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->cond());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSelectMinOp::cond"),
-    nullptr,
-  },
-  {
-    "true_val",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->true_val());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSelectMinOp::true_val"),
-    nullptr,
-  },
-  {
-    "false_val",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->false_val());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSelectMinOp::false_val"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSelectMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSelectMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSelectMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSelectMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1213]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPSelectMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPSelectMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPSelectMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPSelectMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPSelectMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPShlOp.cpp b/bindings/Python/Generated/IR/LLVM/VPShlOp.cpp
deleted file mode 100644
index 07b6ce09b..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPShlOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPShlOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1214]) || tp >= &(gTypes[1215])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPShlOp::static_kind():
-      tp = &(gTypes[1214]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPShlOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPShlOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPShlOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPShlOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPShlOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPShlOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPShlOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPShlOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1214]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPShlOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPShlOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPShlOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPShlOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPShlOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPStoreOp.cpp b/bindings/Python/Generated/IR/LLVM/VPStoreOp.cpp
deleted file mode 100644
index 5f6ca9f58..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPStoreOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPStoreOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1215]) || tp >= &(gTypes[1216])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPStoreOp::static_kind():
-      tp = &(gTypes[1215]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPStoreOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStoreOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStoreOp::mask"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStoreOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStoreOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStoreOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1215]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPStoreOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPStoreOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPStoreOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPStoreOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPStoreOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPStridedLoadOp.cpp b/bindings/Python/Generated/IR/LLVM/VPStridedLoadOp.cpp
deleted file mode 100644
index 3e16f3ff5..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPStridedLoadOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPStridedLoadOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1216]) || tp >= &(gTypes[1217])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPStridedLoadOp::static_kind():
-      tp = &(gTypes[1216]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPStridedLoadOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedLoadOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedLoadOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedLoadOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedLoadOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedLoadOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1216]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPStridedLoadOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPStridedLoadOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPStridedLoadOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPStridedLoadOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPStridedLoadOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPStridedStoreOp.cpp b/bindings/Python/Generated/IR/LLVM/VPStridedStoreOp.cpp
deleted file mode 100644
index 270a5169e..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPStridedStoreOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPStridedStoreOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1217]) || tp >= &(gTypes[1218])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPStridedStoreOp::static_kind():
-      tp = &(gTypes[1217]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPStridedStoreOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedStoreOp::value"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedStoreOp::mask"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedStoreOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedStoreOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPStridedStoreOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1217]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPStridedStoreOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPStridedStoreOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPStridedStoreOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPStridedStoreOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPStridedStoreOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPSubOp.cpp b/bindings/Python/Generated/IR/LLVM/VPSubOp.cpp
deleted file mode 100644
index e1c2c0a3c..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPSubOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPSubOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1218]) || tp >= &(gTypes[1219])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPSubOp::static_kind():
-      tp = &(gTypes[1218]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPSubOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSubOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSubOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSubOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSubOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSubOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSubOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPSubOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1218]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPSubOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPSubOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPSubOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPSubOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPSubOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPTruncOp.cpp b/bindings/Python/Generated/IR/LLVM/VPTruncOp.cpp
deleted file mode 100644
index f7271bb6a..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPTruncOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPTruncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1219]) || tp >= &(gTypes[1220])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPTruncOp::static_kind():
-      tp = &(gTypes[1219]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPTruncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPTruncOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPTruncOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPTruncOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPTruncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPTruncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPTruncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1219]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPTruncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPTruncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPTruncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPTruncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPTruncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPUDivOp.cpp b/bindings/Python/Generated/IR/LLVM/VPUDivOp.cpp
deleted file mode 100644
index c1c7b993b..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPUDivOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPUDivOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1220]) || tp >= &(gTypes[1221])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPUDivOp::static_kind():
-      tp = &(gTypes[1220]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPUDivOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUDivOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUDivOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUDivOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUDivOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUDivOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUDivOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUDivOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1220]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPUDivOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPUDivOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPUDivOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPUDivOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPUDivOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPUIToFPOp.cpp b/bindings/Python/Generated/IR/LLVM/VPUIToFPOp.cpp
deleted file mode 100644
index 9f1b4d8d2..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPUIToFPOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPUIToFPOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1221]) || tp >= &(gTypes[1222])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPUIToFPOp::static_kind():
-      tp = &(gTypes[1221]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPUIToFPOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUIToFPOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUIToFPOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUIToFPOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUIToFPOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUIToFPOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPUIToFPOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1221]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPUIToFPOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPUIToFPOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPUIToFPOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPUIToFPOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPUIToFPOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPURemOp.cpp b/bindings/Python/Generated/IR/LLVM/VPURemOp.cpp
deleted file mode 100644
index 2802d797e..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPURemOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPURemOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1222]) || tp >= &(gTypes[1223])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPURemOp::static_kind():
-      tp = &(gTypes[1222]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPURemOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPURemOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPURemOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPURemOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPURemOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPURemOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPURemOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPURemOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1222]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPURemOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPURemOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPURemOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPURemOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPURemOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPXorOp.cpp b/bindings/Python/Generated/IR/LLVM/VPXorOp.cpp
deleted file mode 100644
index 443df60ac..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPXorOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPXorOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1223]) || tp >= &(gTypes[1224])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPXorOp::static_kind():
-      tp = &(gTypes[1223]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPXorOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPXorOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPXorOp::right"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPXorOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPXorOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPXorOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPXorOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPXorOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1223]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPXorOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPXorOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPXorOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPXorOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPXorOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VPZExtOp.cpp b/bindings/Python/Generated/IR/LLVM/VPZExtOp.cpp
deleted file mode 100644
index 78aa1281b..000000000
--- a/bindings/Python/Generated/IR/LLVM/VPZExtOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VPZExtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1224]) || tp >= &(gTypes[1225])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VPZExtOp::static_kind():
-      tp = &(gTypes[1224]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VPZExtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPZExtOp::source"),
-    nullptr,
-  },
-  {
-    "mask",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->mask());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPZExtOp::mask"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPZExtOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPZExtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPZExtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VPZExtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1224]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VPZExtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VPZExtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VPZExtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VPZExtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VPZExtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VScaleOp.cpp b/bindings/Python/Generated/IR/LLVM/VScaleOp.cpp
deleted file mode 100644
index 48746a5fc..000000000
--- a/bindings/Python/Generated/IR/LLVM/VScaleOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VScaleOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1250]) || tp >= &(gTypes[1251])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VScaleOp::static_kind():
-      tp = &(gTypes[1250]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VScaleOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VScaleOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VScaleOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VScaleOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VScaleOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1250]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VScaleOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VScaleOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VScaleOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VScaleOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VScaleOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VScaleRangeAttr.cpp b/bindings/Python/Generated/IR/LLVM/VScaleRangeAttr.cpp
deleted file mode 100644
index 8b6afc194..000000000
--- a/bindings/Python/Generated/IR/LLVM/VScaleRangeAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VScaleRangeAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[934]) || tp >= &(gTypes[935])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VScaleRangeAttr::static_kind():
-      tp = &(gTypes[934]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VScaleRangeAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VScaleRangeAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VScaleRangeAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[934]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VScaleRangeAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VScaleRangeAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[892].tp_hash;
-  tp->tp_richcompare = gTypes[892].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[892]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VScaleRangeAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VScaleRangeAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VScaleRangeAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VaCopyOp.cpp b/bindings/Python/Generated/IR/LLVM/VaCopyOp.cpp
deleted file mode 100644
index ed928bec2..000000000
--- a/bindings/Python/Generated/IR/LLVM/VaCopyOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VaCopyOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1225]) || tp >= &(gTypes[1226])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VaCopyOp::static_kind():
-      tp = &(gTypes[1225]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VaCopyOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VaCopyOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VaCopyOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VaCopyOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1225]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VaCopyOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VaCopyOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VaCopyOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VaCopyOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VaCopyOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VaEndOp.cpp b/bindings/Python/Generated/IR/LLVM/VaEndOp.cpp
deleted file mode 100644
index fde274d62..000000000
--- a/bindings/Python/Generated/IR/LLVM/VaEndOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VaEndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1226]) || tp >= &(gTypes[1227])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VaEndOp::static_kind():
-      tp = &(gTypes[1226]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VaEndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VaEndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VaEndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VaEndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1226]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VaEndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VaEndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VaEndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VaEndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VaEndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VaStartOp.cpp b/bindings/Python/Generated/IR/LLVM/VaStartOp.cpp
deleted file mode 100644
index 9845d2f33..000000000
--- a/bindings/Python/Generated/IR/LLVM/VaStartOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VaStartOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1227]) || tp >= &(gTypes[1228])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VaStartOp::static_kind():
-      tp = &(gTypes[1227]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VaStartOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VaStartOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VaStartOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VaStartOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1227]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VaStartOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VaStartOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VaStartOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VaStartOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VaStartOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VarAnnotationOp.cpp b/bindings/Python/Generated/IR/LLVM/VarAnnotationOp.cpp
deleted file mode 100644
index 8eb4e0055..000000000
--- a/bindings/Python/Generated/IR/LLVM/VarAnnotationOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VarAnnotationOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1228]) || tp >= &(gTypes[1229])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VarAnnotationOp::static_kind():
-      tp = &(gTypes[1228]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VarAnnotationOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VarAnnotationOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VarAnnotationOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VarAnnotationOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1228]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VarAnnotationOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VarAnnotationOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VarAnnotationOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VarAnnotationOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VarAnnotationOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorExtractOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorExtractOp.cpp
deleted file mode 100644
index feb6032bd..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorExtractOp.cpp
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorExtractOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1233]) || tp >= &(gTypes[1234])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorExtractOp::static_kind():
-      tp = &(gTypes[1233]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorExtractOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "srcvec",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->srcvec());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorExtractOp::srcvec"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorExtractOp::result"),
-    nullptr,
-  },
-  {
-    "pos",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->pos());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorExtractOp::pos"),
-    nullptr,
-  },
-  {
-    "src_vector_bit_width",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->src_vector_bit_width());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorExtractOp::src_vector_bit_width"),
-    nullptr,
-  },
-  {
-    "res_vector_bit_width",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->res_vector_bit_width());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorExtractOp::res_vector_bit_width"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorExtractOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorExtractOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorExtractOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1233]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorExtractOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorExtractOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorExtractOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorExtractOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorExtractOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorInsertOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorInsertOp.cpp
deleted file mode 100644
index f639e02c7..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorInsertOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorInsertOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1234]) || tp >= &(gTypes[1235])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorInsertOp::static_kind():
-      tp = &(gTypes[1234]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorInsertOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "dstvec",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->dstvec());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorInsertOp::dstvec"),
-    nullptr,
-  },
-  {
-    "srcvec",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->srcvec());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorInsertOp::srcvec"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorInsertOp::result"),
-    nullptr,
-  },
-  {
-    "pos",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->pos());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorInsertOp::pos"),
-    nullptr,
-  },
-  {
-    "src_vector_bit_width",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->src_vector_bit_width());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorInsertOp::src_vector_bit_width"),
-    nullptr,
-  },
-  {
-    "dst_vector_bit_width",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->dst_vector_bit_width());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorInsertOp::dst_vector_bit_width"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorInsertOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorInsertOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorInsertOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1234]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorInsertOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorInsertOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorInsertOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorInsertOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorInsertOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceAddOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceAddOp.cpp
deleted file mode 100644
index 26707ba4f..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceAddOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceAddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1235]) || tp >= &(gTypes[1236])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceAddOp::static_kind():
-      tp = &(gTypes[1235]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceAddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAddOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1235]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceAddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceAddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceAddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceAddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceAddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceAndOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceAndOp.cpp
deleted file mode 100644
index 85df0e26c..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceAndOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceAndOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1236]) || tp >= &(gTypes[1237])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceAndOp::static_kind():
-      tp = &(gTypes[1236]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceAndOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAndOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAndOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAndOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAndOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceAndOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1236]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceAndOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceAndOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceAndOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceAndOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceAndOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceFAddOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceFAddOp.cpp
deleted file mode 100644
index a4c881d97..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceFAddOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceFAddOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1237]) || tp >= &(gTypes[1238])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceFAddOp::static_kind():
-      tp = &(gTypes[1237]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceFAddOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "input",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->input());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFAddOp::input"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFAddOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFAddOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFAddOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFAddOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1237]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceFAddOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceFAddOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceFAddOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceFAddOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceFAddOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceFMaxOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceFMaxOp.cpp
deleted file mode 100644
index 314a85145..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceFMaxOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceFMaxOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1238]) || tp >= &(gTypes[1239])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceFMaxOp::static_kind():
-      tp = &(gTypes[1238]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceFMaxOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaxOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaxOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaxOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaxOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaxOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1238]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceFMaxOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceFMaxOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceFMaxOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceFMaxOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceFMaxOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceFMaximumOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceFMaximumOp.cpp
deleted file mode 100644
index 1fc1df53e..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceFMaximumOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceFMaximumOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1239]) || tp >= &(gTypes[1240])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceFMaximumOp::static_kind():
-      tp = &(gTypes[1239]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceFMaximumOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaximumOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaximumOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaximumOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaximumOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMaximumOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1239]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceFMaximumOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceFMaximumOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceFMaximumOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceFMaximumOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceFMaximumOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceFMinOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceFMinOp.cpp
deleted file mode 100644
index 802f267d3..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceFMinOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceFMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1240]) || tp >= &(gTypes[1241])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceFMinOp::static_kind():
-      tp = &(gTypes[1240]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceFMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1240]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceFMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceFMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceFMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceFMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceFMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceFMinimumOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceFMinimumOp.cpp
deleted file mode 100644
index 75305c014..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceFMinimumOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceFMinimumOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1241]) || tp >= &(gTypes[1242])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceFMinimumOp::static_kind():
-      tp = &(gTypes[1241]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceFMinimumOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinimumOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinimumOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinimumOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinimumOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMinimumOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1241]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceFMinimumOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceFMinimumOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceFMinimumOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceFMinimumOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceFMinimumOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceFMulOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceFMulOp.cpp
deleted file mode 100644
index 14f900578..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceFMulOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceFMulOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1242]) || tp >= &(gTypes[1243])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceFMulOp::static_kind():
-      tp = &(gTypes[1242]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceFMulOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "input",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->input());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMulOp::input"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMulOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMulOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMulOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceFMulOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1242]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceFMulOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceFMulOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceFMulOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceFMulOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceFMulOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceMulOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceMulOp.cpp
deleted file mode 100644
index faa032da0..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceMulOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceMulOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1243]) || tp >= &(gTypes[1244])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceMulOp::static_kind():
-      tp = &(gTypes[1243]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceMulOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceMulOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceMulOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceMulOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceMulOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceMulOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1243]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceMulOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceMulOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceMulOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceMulOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceMulOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceOrOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceOrOp.cpp
deleted file mode 100644
index 3076bd98d..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceOrOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceOrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1244]) || tp >= &(gTypes[1245])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceOrOp::static_kind():
-      tp = &(gTypes[1244]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceOrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceOrOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceOrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceOrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceOrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceOrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1244]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceOrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceOrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceOrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceOrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceOrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceSMaxOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceSMaxOp.cpp
deleted file mode 100644
index ae5eebd11..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceSMaxOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceSMaxOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1245]) || tp >= &(gTypes[1246])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceSMaxOp::static_kind():
-      tp = &(gTypes[1245]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceSMaxOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMaxOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMaxOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMaxOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMaxOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMaxOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1245]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceSMaxOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceSMaxOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceSMaxOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceSMaxOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceSMaxOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceSMinOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceSMinOp.cpp
deleted file mode 100644
index 6e2e2fb24..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceSMinOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceSMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1246]) || tp >= &(gTypes[1247])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceSMinOp::static_kind():
-      tp = &(gTypes[1246]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceSMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMinOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceSMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1246]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceSMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceSMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceSMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceSMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceSMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceUMaxOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceUMaxOp.cpp
deleted file mode 100644
index f5387761f..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceUMaxOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceUMaxOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1247]) || tp >= &(gTypes[1248])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceUMaxOp::static_kind():
-      tp = &(gTypes[1247]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceUMaxOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMaxOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMaxOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMaxOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMaxOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMaxOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1247]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceUMaxOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceUMaxOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceUMaxOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceUMaxOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceUMaxOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceUMinOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceUMinOp.cpp
deleted file mode 100644
index b249337e4..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceUMinOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceUMinOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1248]) || tp >= &(gTypes[1249])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceUMinOp::static_kind():
-      tp = &(gTypes[1248]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceUMinOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMinOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMinOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMinOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMinOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceUMinOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1248]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceUMinOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceUMinOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceUMinOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceUMinOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceUMinOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/VectorReduceXorOp.cpp b/bindings/Python/Generated/IR/LLVM/VectorReduceXorOp.cpp
deleted file mode 100644
index a5946b205..000000000
--- a/bindings/Python/Generated/IR/LLVM/VectorReduceXorOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::VectorReduceXorOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1249]) || tp >= &(gTypes[1250])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::VectorReduceXorOp::static_kind():
-      tp = &(gTypes[1249]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "VectorReduceXorOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "IN",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->in());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceXorOp::in"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceXorOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceXorOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceXorOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::VectorReduceXorOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1249]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.VectorReduceXorOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::VectorReduceXorOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'VectorReduceXorOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'VectorReduceXorOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'VectorReduceXorOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/XOrOp.cpp b/bindings/Python/Generated/IR/LLVM/XOrOp.cpp
deleted file mode 100644
index 487b176ff..000000000
--- a/bindings/Python/Generated/IR/LLVM/XOrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::XOrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1072]) || tp >= &(gTypes[1073])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::XOrOp::static_kind():
-      tp = &(gTypes[1072]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "XOrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "left",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->left());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::XOrOp::left"),
-    nullptr,
-  },
-  {
-    "right",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->right());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::XOrOp::right"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::XOrOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::XOrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::XOrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::XOrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1072]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.XOrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::XOrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'XOrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'XOrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'XOrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ZExtOp.cpp b/bindings/Python/Generated/IR/LLVM/ZExtOp.cpp
deleted file mode 100644
index 1959137b4..000000000
--- a/bindings/Python/Generated/IR/LLVM/ZExtOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ZExtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1073]) || tp >= &(gTypes[1074])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ZExtOp::static_kind():
-      tp = &(gTypes[1073]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ZExtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ZExtOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ZExtOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ZExtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ZExtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ZExtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1073]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ZExtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ZExtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ZExtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ZExtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ZExtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LLVM/ZeroOp.cpp b/bindings/Python/Generated/IR/LLVM/ZeroOp.cpp
deleted file mode 100644
index 474035722..000000000
--- a/bindings/Python/Generated/IR/LLVM/ZeroOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::llvm::ZeroOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1074]) || tp >= &(gTypes[1075])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::llvm::ZeroOp::static_kind():
-      tp = &(gTypes[1074]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ZeroOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ZeroOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ZeroOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ZeroOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::llvm::ZeroOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1074]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.llvm.ZeroOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::llvm::::ZeroOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1002].tp_hash;
-  tp->tp_richcompare = gTypes[1002].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1002]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ZeroOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ZeroOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ZeroOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Label.cpp b/bindings/Python/Generated/IR/Label.cpp
deleted file mode 100644
index 8607bdcd4..000000000
--- a/bindings/Python/Generated/IR/Label.cpp
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Block.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Label;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[997]) || tp >= &(gTypes[998])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  auto ret = gType->tp_alloc(gType, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Label", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "operation",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->operation());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Label::operation"),
-    nullptr,
-  },
-  {
-    "block",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->block());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Label::block"),
-    nullptr,
-  },
-  {
-    "index",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->index());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Label::index"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[997]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Label";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Label");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = PyObject_HashNotImplemented;
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = nullptr;
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Label.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Label.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Label' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/AllocaOp.cpp b/bindings/Python/Generated/IR/LowLevel/AllocaOp.cpp
deleted file mode 100644
index 7eb8446b2..000000000
--- a/bindings/Python/Generated/IR/LowLevel/AllocaOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::AllocaOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1296]) || tp >= &(gTypes[1297])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::AllocaOp::static_kind():
-      tp = &(gTypes[1296]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AllocaOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::AllocaOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::AllocaOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::AllocaOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::AllocaOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1296]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.AllocaOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::AllocaOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AllocaOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AllocaOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AllocaOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/ArgAllocaOp.cpp b/bindings/Python/Generated/IR/LowLevel/ArgAllocaOp.cpp
deleted file mode 100644
index 90d7416fa..000000000
--- a/bindings/Python/Generated/IR/LowLevel/ArgAllocaOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::ArgAllocaOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1297]) || tp >= &(gTypes[1298])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::ArgAllocaOp::static_kind():
-      tp = &(gTypes[1297]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ArgAllocaOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "fn_arg",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->fn_arg());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::ArgAllocaOp::fn_arg"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::ArgAllocaOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ArgAllocaOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ArgAllocaOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ArgAllocaOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1297]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.ArgAllocaOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::ArgAllocaOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ArgAllocaOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ArgAllocaOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ArgAllocaOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/BrOp.cpp b/bindings/Python/Generated/IR/LowLevel/BrOp.cpp
deleted file mode 100644
index 9d8f6a3fd..000000000
--- a/bindings/Python/Generated/IR/LowLevel/BrOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::BrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1298]) || tp >= &(gTypes[1299])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::BrOp::static_kind():
-      tp = &(gTypes[1298]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "BrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::BrOp::operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::BrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::BrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::BrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1298]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.BrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::BrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'BrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'BrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'BrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/ConcatOp.cpp b/bindings/Python/Generated/IR/LowLevel/ConcatOp.cpp
deleted file mode 100644
index ec84875e2..000000000
--- a/bindings/Python/Generated/IR/LowLevel/ConcatOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::ConcatOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1299]) || tp >= &(gTypes[1300])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::ConcatOp::static_kind():
-      tp = &(gTypes[1299]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ConcatOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "arguments",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::arguments);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::ConcatOp::arguments"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::ConcatOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ConcatOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ConcatOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ConcatOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1299]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.ConcatOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::ConcatOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ConcatOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ConcatOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ConcatOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/CondBrOp.cpp b/bindings/Python/Generated/IR/LowLevel/CondBrOp.cpp
deleted file mode 100644
index faebf79a1..000000000
--- a/bindings/Python/Generated/IR/LowLevel/CondBrOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::CondBrOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1300]) || tp >= &(gTypes[1301])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::CondBrOp::static_kind():
-      tp = &(gTypes[1300]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CondBrOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "cond",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->cond());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondBrOp::cond"),
-    nullptr,
-  },
-  {
-    "true_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::true_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondBrOp::true_operands"),
-    nullptr,
-  },
-  {
-    "false_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::false_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondBrOp::false_operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondBrOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondBrOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondBrOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1300]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.CondBrOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::CondBrOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CondBrOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CondBrOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CondBrOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/CondScopeRetOp.cpp b/bindings/Python/Generated/IR/LowLevel/CondScopeRetOp.cpp
deleted file mode 100644
index 7c1b194cf..000000000
--- a/bindings/Python/Generated/IR/LowLevel/CondScopeRetOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::CondScopeRetOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1301]) || tp >= &(gTypes[1302])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::CondScopeRetOp::static_kind():
-      tp = &(gTypes[1301]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CondScopeRetOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "cond",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->cond());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondScopeRetOp::cond"),
-    nullptr,
-  },
-  {
-    "dest_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::dest_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondScopeRetOp::dest_operands"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondScopeRetOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondScopeRetOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::CondScopeRetOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1301]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.CondScopeRetOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::CondScopeRetOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CondScopeRetOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CondScopeRetOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CondScopeRetOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/ExtractOp.cpp b/bindings/Python/Generated/IR/LowLevel/ExtractOp.cpp
deleted file mode 100644
index afeaed91d..000000000
--- a/bindings/Python/Generated/IR/LowLevel/ExtractOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::ExtractOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1302]) || tp >= &(gTypes[1303])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::ExtractOp::static_kind():
-      tp = &(gTypes[1302]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExtractOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "argument",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->argument());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::ExtractOp::argument"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::ExtractOp::result"),
-    nullptr,
-  },
-  {
-    "size",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->size());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::ExtractOp::size"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ExtractOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ExtractOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ExtractOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1302]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.ExtractOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::ExtractOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExtractOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExtractOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExtractOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/FuncOp.cpp b/bindings/Python/Generated/IR/LowLevel/FuncOp.cpp
deleted file mode 100644
index 38d626127..000000000
--- a/bindings/Python/Generated/IR/LowLevel/FuncOp.cpp
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::FuncOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1306]) || tp >= &(gTypes[1307])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::FuncOp::static_kind():
-      tp = &(gTypes[1306]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "FuncOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::body"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::name"),
-    nullptr,
-  },
-  {
-    "function_type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->function_type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::function_type"),
-    nullptr,
-  },
-  {
-    "visibility",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->visibility());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::visibility"),
-    nullptr,
-  },
-  {
-    "is_var_arg",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_var_arg());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::is_var_arg"),
-    nullptr,
-  },
-  {
-    "callable_results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::callable_results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::callable_results"),
-    nullptr,
-  },
-  {
-    "argument_types",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::argument_types);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::argument_types"),
-    nullptr,
-  },
-  {
-    "result_types",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::result_types);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::result_types"),
-    nullptr,
-  },
-  {
-    "is_declaration",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_declaration());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::is_declaration"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::FuncOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1306]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.FuncOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::FuncOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'FuncOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'FuncOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'FuncOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/InitializeVarOp.cpp b/bindings/Python/Generated/IR/LowLevel/InitializeVarOp.cpp
deleted file mode 100644
index 26290fd06..000000000
--- a/bindings/Python/Generated/IR/LowLevel/InitializeVarOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::InitializeVarOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1303]) || tp >= &(gTypes[1304])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::InitializeVarOp::static_kind():
-      tp = &(gTypes[1303]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InitializeVarOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "var",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->var());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::InitializeVarOp::var"),
-    nullptr,
-  },
-  {
-    "elements",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::elements);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::InitializeVarOp::elements"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::InitializeVarOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::InitializeVarOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::InitializeVarOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::InitializeVarOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1303]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.InitializeVarOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::InitializeVarOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InitializeVarOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InitializeVarOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InitializeVarOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/InlineScopeOp.cpp b/bindings/Python/Generated/IR/LowLevel/InlineScopeOp.cpp
deleted file mode 100644
index 4cd4f55f0..000000000
--- a/bindings/Python/Generated/IR/LowLevel/InlineScopeOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::InlineScopeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1304]) || tp >= &(gTypes[1305])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::InlineScopeOp::static_kind():
-      tp = &(gTypes[1304]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "InlineScopeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::InlineScopeOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::InlineScopeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::InlineScopeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::InlineScopeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1304]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.InlineScopeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::InlineScopeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'InlineScopeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'InlineScopeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'InlineScopeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/LoadOp.cpp b/bindings/Python/Generated/IR/LowLevel/LoadOp.cpp
deleted file mode 100644
index 04e537378..000000000
--- a/bindings/Python/Generated/IR/LowLevel/LoadOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::LoadOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1305]) || tp >= &(gTypes[1306])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::LoadOp::static_kind():
-      tp = &(gTypes[1305]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoadOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::LoadOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::LoadOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::LoadOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::LoadOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1305]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.LoadOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::LoadOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoadOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoadOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoadOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/Operation.cpp b/bindings/Python/Generated/IR/LowLevel/Operation.cpp
deleted file mode 100644
index a4a809807..000000000
--- a/bindings/Python/Generated/IR/LowLevel/Operation.cpp
+++ /dev/null
@@ -1,289 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::Operation;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1295]) || tp >= &(gTypes[1315])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::AllocaOp::static_kind():
-      tp = &(gTypes[1296]);
-      break;
-
-    case mx::ir::ll::ArgAllocaOp::static_kind():
-      tp = &(gTypes[1297]);
-      break;
-
-    case mx::ir::ll::BrOp::static_kind():
-      tp = &(gTypes[1298]);
-      break;
-
-    case mx::ir::ll::ConcatOp::static_kind():
-      tp = &(gTypes[1299]);
-      break;
-
-    case mx::ir::ll::CondBrOp::static_kind():
-      tp = &(gTypes[1300]);
-      break;
-
-    case mx::ir::ll::CondScopeRetOp::static_kind():
-      tp = &(gTypes[1301]);
-      break;
-
-    case mx::ir::ll::ExtractOp::static_kind():
-      tp = &(gTypes[1302]);
-      break;
-
-    case mx::ir::ll::InitializeVarOp::static_kind():
-      tp = &(gTypes[1303]);
-      break;
-
-    case mx::ir::ll::InlineScopeOp::static_kind():
-      tp = &(gTypes[1304]);
-      break;
-
-    case mx::ir::ll::LoadOp::static_kind():
-      tp = &(gTypes[1305]);
-      break;
-
-    case mx::ir::ll::FuncOp::static_kind():
-      tp = &(gTypes[1306]);
-      break;
-
-    case mx::ir::ll::StructGEPOp::static_kind():
-      tp = &(gTypes[1307]);
-      break;
-
-    case mx::ir::ll::ReturnOp::static_kind():
-      tp = &(gTypes[1308]);
-      break;
-
-    case mx::ir::ll::ScopeOp::static_kind():
-      tp = &(gTypes[1309]);
-      break;
-
-    case mx::ir::ll::ScopeRecurseOp::static_kind():
-      tp = &(gTypes[1310]);
-      break;
-
-    case mx::ir::ll::ScopeRetOp::static_kind():
-      tp = &(gTypes[1311]);
-      break;
-
-    case mx::ir::ll::StoreOp::static_kind():
-      tp = &(gTypes[1312]);
-      break;
-
-    case mx::ir::ll::SubscriptOp::static_kind():
-      tp = &(gTypes[1313]);
-      break;
-
-    case mx::ir::ll::UninitializedVarOp::static_kind():
-      tp = &(gTypes[1314]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operation", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::Operation::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1295]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.Operation";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::Operation");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[998].tp_hash;
-  tp->tp_richcompare = gTypes[998].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[998]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operation.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operation.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operation' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/ReturnOp.cpp b/bindings/Python/Generated/IR/LowLevel/ReturnOp.cpp
deleted file mode 100644
index 83775fbe2..000000000
--- a/bindings/Python/Generated/IR/LowLevel/ReturnOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::ReturnOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1308]) || tp >= &(gTypes[1309])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::ReturnOp::static_kind():
-      tp = &(gTypes[1308]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ReturnOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::result);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::ReturnOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ReturnOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ReturnOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ReturnOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1308]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.ReturnOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::ReturnOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ReturnOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ReturnOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ReturnOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/ScopeOp.cpp b/bindings/Python/Generated/IR/LowLevel/ScopeOp.cpp
deleted file mode 100644
index 212f9013b..000000000
--- a/bindings/Python/Generated/IR/LowLevel/ScopeOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::ScopeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1309]) || tp >= &(gTypes[1310])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::ScopeOp::static_kind():
-      tp = &(gTypes[1309]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ScopeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeOp::body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1309]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.ScopeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::ScopeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ScopeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ScopeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ScopeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/ScopeRecurseOp.cpp b/bindings/Python/Generated/IR/LowLevel/ScopeRecurseOp.cpp
deleted file mode 100644
index 9cfe91e4b..000000000
--- a/bindings/Python/Generated/IR/LowLevel/ScopeRecurseOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::ScopeRecurseOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1310]) || tp >= &(gTypes[1311])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::ScopeRecurseOp::static_kind():
-      tp = &(gTypes[1310]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ScopeRecurseOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeRecurseOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeRecurseOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeRecurseOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1310]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.ScopeRecurseOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::ScopeRecurseOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ScopeRecurseOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ScopeRecurseOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ScopeRecurseOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/ScopeRetOp.cpp b/bindings/Python/Generated/IR/LowLevel/ScopeRetOp.cpp
deleted file mode 100644
index a67c05c8e..000000000
--- a/bindings/Python/Generated/IR/LowLevel/ScopeRetOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::ScopeRetOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1311]) || tp >= &(gTypes[1312])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::ScopeRetOp::static_kind():
-      tp = &(gTypes[1311]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ScopeRetOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeRetOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeRetOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::ScopeRetOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1311]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.ScopeRetOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::ScopeRetOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ScopeRetOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ScopeRetOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ScopeRetOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/StoreOp.cpp b/bindings/Python/Generated/IR/LowLevel/StoreOp.cpp
deleted file mode 100644
index eb8cceafe..000000000
--- a/bindings/Python/Generated/IR/LowLevel/StoreOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::StoreOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1312]) || tp >= &(gTypes[1313])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::StoreOp::static_kind():
-      tp = &(gTypes[1312]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StoreOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::StoreOp::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::StoreOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::StoreOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::StoreOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1312]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.StoreOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::StoreOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StoreOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StoreOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StoreOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/StructGEPOp.cpp b/bindings/Python/Generated/IR/LowLevel/StructGEPOp.cpp
deleted file mode 100644
index 748a8987b..000000000
--- a/bindings/Python/Generated/IR/LowLevel/StructGEPOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::StructGEPOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1307]) || tp >= &(gTypes[1308])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::StructGEPOp::static_kind():
-      tp = &(gTypes[1307]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StructGEPOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "record",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->record());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::StructGEPOp::record"),
-    nullptr,
-  },
-  {
-    "element",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->element());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::StructGEPOp::element"),
-    nullptr,
-  },
-  {
-    "idx",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->idx());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::StructGEPOp::idx"),
-    nullptr,
-  },
-  {
-    "field",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->field());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::StructGEPOp::field"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::StructGEPOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::StructGEPOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::StructGEPOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1307]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.StructGEPOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::StructGEPOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StructGEPOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StructGEPOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StructGEPOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/SubscriptOp.cpp b/bindings/Python/Generated/IR/LowLevel/SubscriptOp.cpp
deleted file mode 100644
index 6df1cfb3c..000000000
--- a/bindings/Python/Generated/IR/LowLevel/SubscriptOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::SubscriptOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1313]) || tp >= &(gTypes[1314])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::SubscriptOp::static_kind():
-      tp = &(gTypes[1313]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SubscriptOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "array",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->array());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::SubscriptOp::array"),
-    nullptr,
-  },
-  {
-    "index",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->index());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::SubscriptOp::index"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::SubscriptOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::SubscriptOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::SubscriptOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::SubscriptOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1313]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.SubscriptOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::SubscriptOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SubscriptOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SubscriptOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SubscriptOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/LowLevel/UninitializedVarOp.cpp b/bindings/Python/Generated/IR/LowLevel/UninitializedVarOp.cpp
deleted file mode 100644
index 7d1b9b80e..000000000
--- a/bindings/Python/Generated/IR/LowLevel/UninitializedVarOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::ll::UninitializedVarOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1314]) || tp >= &(gTypes[1315])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::ll::UninitializedVarOp::static_kind():
-      tp = &(gTypes[1314]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UninitializedVarOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::ll::UninitializedVarOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::UninitializedVarOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::UninitializedVarOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::ll::UninitializedVarOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1314]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.lowlevel.UninitializedVarOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::ll::::UninitializedVarOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1295].tp_hash;
-  tp->tp_richcompare = gTypes[1295].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1295]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UninitializedVarOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UninitializedVarOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UninitializedVarOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/AllocOp.cpp b/bindings/Python/Generated/IR/MemRef/AllocOp.cpp
deleted file mode 100644
index 7ca083e8d..000000000
--- a/bindings/Python/Generated/IR/MemRef/AllocOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::AllocOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1258]) || tp >= &(gTypes[1259])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::AllocOp::static_kind():
-      tp = &(gTypes[1258]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AllocOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "dynamic_sizes",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::dynamic_sizes);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocOp::dynamic_sizes"),
-    nullptr,
-  },
-  {
-    "symbol_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::symbol_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocOp::symbol_operands"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocOp::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1258]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.AllocOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::AllocOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AllocOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AllocOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AllocOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/AllocaOp.cpp b/bindings/Python/Generated/IR/MemRef/AllocaOp.cpp
deleted file mode 100644
index 8366799dc..000000000
--- a/bindings/Python/Generated/IR/MemRef/AllocaOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::AllocaOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1259]) || tp >= &(gTypes[1260])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::AllocaOp::static_kind():
-      tp = &(gTypes[1259]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AllocaOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "dynamic_sizes",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::dynamic_sizes);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaOp::dynamic_sizes"),
-    nullptr,
-  },
-  {
-    "symbol_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::symbol_operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaOp::symbol_operands"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaOp::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1259]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.AllocaOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::AllocaOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AllocaOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AllocaOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AllocaOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/AllocaScopeOp.cpp b/bindings/Python/Generated/IR/MemRef/AllocaScopeOp.cpp
deleted file mode 100644
index fe709ac0f..000000000
--- a/bindings/Python/Generated/IR/MemRef/AllocaScopeOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::AllocaScopeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1260]) || tp >= &(gTypes[1261])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::AllocaScopeOp::static_kind():
-      tp = &(gTypes[1260]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AllocaScopeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaScopeOp::results"),
-    nullptr,
-  },
-  {
-    "body_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaScopeOp::body_region"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaScopeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaScopeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaScopeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1260]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.AllocaScopeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::AllocaScopeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AllocaScopeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AllocaScopeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AllocaScopeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/AllocaScopeReturnOp.cpp b/bindings/Python/Generated/IR/MemRef/AllocaScopeReturnOp.cpp
deleted file mode 100644
index 6636c7f84..000000000
--- a/bindings/Python/Generated/IR/MemRef/AllocaScopeReturnOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::AllocaScopeReturnOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1261]) || tp >= &(gTypes[1262])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::AllocaScopeReturnOp::static_kind():
-      tp = &(gTypes[1261]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AllocaScopeReturnOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaScopeReturnOp::results"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaScopeReturnOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaScopeReturnOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AllocaScopeReturnOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1261]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.AllocaScopeReturnOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::AllocaScopeReturnOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AllocaScopeReturnOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AllocaScopeReturnOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AllocaScopeReturnOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/AssumeAlignmentOp.cpp b/bindings/Python/Generated/IR/MemRef/AssumeAlignmentOp.cpp
deleted file mode 100644
index 06cb7c753..000000000
--- a/bindings/Python/Generated/IR/MemRef/AssumeAlignmentOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::AssumeAlignmentOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1252]) || tp >= &(gTypes[1253])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::AssumeAlignmentOp::static_kind():
-      tp = &(gTypes[1252]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AssumeAlignmentOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AssumeAlignmentOp::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AssumeAlignmentOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AssumeAlignmentOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AssumeAlignmentOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1252]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.AssumeAlignmentOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::AssumeAlignmentOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AssumeAlignmentOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AssumeAlignmentOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AssumeAlignmentOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/AtomicRMWOp.cpp b/bindings/Python/Generated/IR/MemRef/AtomicRMWOp.cpp
deleted file mode 100644
index 20f2677ac..000000000
--- a/bindings/Python/Generated/IR/MemRef/AtomicRMWOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::AtomicRMWOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1253]) || tp >= &(gTypes[1254])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::AtomicRMWOp::static_kind():
-      tp = &(gTypes[1253]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AtomicRMWOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicRMWOp::value"),
-    nullptr,
-  },
-  {
-    "indices",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::indices);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicRMWOp::indices"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicRMWOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicRMWOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicRMWOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicRMWOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1253]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.AtomicRMWOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::AtomicRMWOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AtomicRMWOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AtomicRMWOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AtomicRMWOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/AtomicYieldOp.cpp b/bindings/Python/Generated/IR/MemRef/AtomicYieldOp.cpp
deleted file mode 100644
index 9834f9599..000000000
--- a/bindings/Python/Generated/IR/MemRef/AtomicYieldOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::AtomicYieldOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1254]) || tp >= &(gTypes[1255])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::AtomicYieldOp::static_kind():
-      tp = &(gTypes[1254]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "AtomicYieldOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicYieldOp::result"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicYieldOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicYieldOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::AtomicYieldOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1254]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.AtomicYieldOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::AtomicYieldOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'AtomicYieldOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'AtomicYieldOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'AtomicYieldOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/CastOp.cpp b/bindings/Python/Generated/IR/MemRef/CastOp.cpp
deleted file mode 100644
index 1e2514660..000000000
--- a/bindings/Python/Generated/IR/MemRef/CastOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::CastOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1262]) || tp >= &(gTypes[1263])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::CastOp::static_kind():
-      tp = &(gTypes[1262]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CastOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::CastOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::CastOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::CastOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1262]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.CastOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::CastOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CastOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CastOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CastOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/CollapseShapeOp.cpp b/bindings/Python/Generated/IR/MemRef/CollapseShapeOp.cpp
deleted file mode 100644
index e8e931f8c..000000000
--- a/bindings/Python/Generated/IR/MemRef/CollapseShapeOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::CollapseShapeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1263]) || tp >= &(gTypes[1264])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::CollapseShapeOp::static_kind():
-      tp = &(gTypes[1263]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CollapseShapeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::CollapseShapeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::CollapseShapeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::CollapseShapeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1263]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.CollapseShapeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::CollapseShapeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CollapseShapeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CollapseShapeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CollapseShapeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/CopyOp.cpp b/bindings/Python/Generated/IR/MemRef/CopyOp.cpp
deleted file mode 100644
index 06a58d797..000000000
--- a/bindings/Python/Generated/IR/MemRef/CopyOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::CopyOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1255]) || tp >= &(gTypes[1256])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::CopyOp::static_kind():
-      tp = &(gTypes[1255]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "CopyOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::CopyOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::CopyOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::CopyOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1255]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.CopyOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::CopyOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'CopyOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'CopyOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'CopyOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/DMAStartOp.cpp b/bindings/Python/Generated/IR/MemRef/DMAStartOp.cpp
deleted file mode 100644
index ea5b10107..000000000
--- a/bindings/Python/Generated/IR/MemRef/DMAStartOp.cpp
+++ /dev/null
@@ -1,355 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::DMAStartOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1266]) || tp >= &(gTypes[1267])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::DMAStartOp::static_kind():
-      tp = &(gTypes[1266]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DMAStartOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::operands"),
-    nullptr,
-  },
-  {
-    "src_mem_ref_rank",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->src_mem_ref_rank());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::src_mem_ref_rank"),
-    nullptr,
-  },
-  {
-    "dst_mem_ref_rank",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->dst_mem_ref_rank());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::dst_mem_ref_rank"),
-    nullptr,
-  },
-  {
-    "src_memory_space",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->src_memory_space());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::src_memory_space"),
-    nullptr,
-  },
-  {
-    "dst_memory_space",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->dst_memory_space());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::dst_memory_space"),
-    nullptr,
-  },
-  {
-    "tag_mem_ref_rank",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->tag_mem_ref_rank());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::tag_mem_ref_rank"),
-    nullptr,
-  },
-  {
-    "is_dest_memory_space_faster",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_dest_memory_space_faster());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::is_dest_memory_space_faster"),
-    nullptr,
-  },
-  {
-    "is_src_memory_space_faster",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_src_memory_space_faster());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::is_src_memory_space_faster"),
-    nullptr,
-  },
-  {
-    "faster_mem_pos",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->faster_mem_pos());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::faster_mem_pos"),
-    nullptr,
-  },
-  {
-    "is_strided",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_strided());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::is_strided"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAStartOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1266]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.DMAStartOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::DMAStartOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DMAStartOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DMAStartOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DMAStartOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/DMAWaitOp.cpp b/bindings/Python/Generated/IR/MemRef/DMAWaitOp.cpp
deleted file mode 100644
index 24afd9cef..000000000
--- a/bindings/Python/Generated/IR/MemRef/DMAWaitOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::DMAWaitOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1267]) || tp >= &(gTypes[1268])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::DMAWaitOp::static_kind():
-      tp = &(gTypes[1267]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DMAWaitOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "tag_indices",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::tag_indices);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAWaitOp::tag_indices"),
-    nullptr,
-  },
-  {
-    "tag_mem_ref_rank",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->tag_mem_ref_rank());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAWaitOp::tag_mem_ref_rank"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAWaitOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAWaitOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DMAWaitOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1267]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.DMAWaitOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::DMAWaitOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DMAWaitOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DMAWaitOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DMAWaitOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/DeallocOp.cpp b/bindings/Python/Generated/IR/MemRef/DeallocOp.cpp
deleted file mode 100644
index 02a473b85..000000000
--- a/bindings/Python/Generated/IR/MemRef/DeallocOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::DeallocOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1264]) || tp >= &(gTypes[1265])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::DeallocOp::static_kind():
-      tp = &(gTypes[1264]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DeallocOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DeallocOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DeallocOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DeallocOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1264]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.DeallocOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::DeallocOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DeallocOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DeallocOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DeallocOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/DimOp.cpp b/bindings/Python/Generated/IR/MemRef/DimOp.cpp
deleted file mode 100644
index 987bd0dbf..000000000
--- a/bindings/Python/Generated/IR/MemRef/DimOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::DimOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1265]) || tp >= &(gTypes[1266])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::DimOp::static_kind():
-      tp = &(gTypes[1265]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "DimOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DimOp::source"),
-    nullptr,
-  },
-  {
-    "constant_index",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->constant_index());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::DimOp::constant_index"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DimOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DimOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::DimOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1265]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.DimOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::DimOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'DimOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'DimOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'DimOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/ExpandShapeOp.cpp b/bindings/Python/Generated/IR/MemRef/ExpandShapeOp.cpp
deleted file mode 100644
index c799b73d8..000000000
--- a/bindings/Python/Generated/IR/MemRef/ExpandShapeOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::ExpandShapeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1268]) || tp >= &(gTypes[1269])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::ExpandShapeOp::static_kind():
-      tp = &(gTypes[1268]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExpandShapeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExpandShapeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExpandShapeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExpandShapeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1268]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.ExpandShapeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::ExpandShapeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExpandShapeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExpandShapeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExpandShapeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/ExtractAlignedPointerAsIndexOp.cpp b/bindings/Python/Generated/IR/MemRef/ExtractAlignedPointerAsIndexOp.cpp
deleted file mode 100644
index 75c835f24..000000000
--- a/bindings/Python/Generated/IR/MemRef/ExtractAlignedPointerAsIndexOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::ExtractAlignedPointerAsIndexOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1269]) || tp >= &(gTypes[1270])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::ExtractAlignedPointerAsIndexOp::static_kind():
-      tp = &(gTypes[1269]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExtractAlignedPointerAsIndexOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractAlignedPointerAsIndexOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractAlignedPointerAsIndexOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractAlignedPointerAsIndexOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1269]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.ExtractAlignedPointerAsIndexOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::ExtractAlignedPointerAsIndexOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExtractAlignedPointerAsIndexOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExtractAlignedPointerAsIndexOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExtractAlignedPointerAsIndexOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/ExtractStridedMetadataOp.cpp b/bindings/Python/Generated/IR/MemRef/ExtractStridedMetadataOp.cpp
deleted file mode 100644
index 6931eb341..000000000
--- a/bindings/Python/Generated/IR/MemRef/ExtractStridedMetadataOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::ExtractStridedMetadataOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1270]) || tp >= &(gTypes[1271])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::ExtractStridedMetadataOp::static_kind():
-      tp = &(gTypes[1270]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ExtractStridedMetadataOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "base_buffer",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->base_buffer());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractStridedMetadataOp::base_buffer"),
-    nullptr,
-  },
-  {
-    "sizes",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::sizes);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractStridedMetadataOp::sizes"),
-    nullptr,
-  },
-  {
-    "strides",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::strides);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractStridedMetadataOp::strides"),
-    nullptr,
-  },
-  {
-    "view_source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->view_source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractStridedMetadataOp::view_source"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractStridedMetadataOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractStridedMetadataOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ExtractStridedMetadataOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1270]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.ExtractStridedMetadataOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::ExtractStridedMetadataOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ExtractStridedMetadataOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ExtractStridedMetadataOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ExtractStridedMetadataOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/GenericAtomicRMWOp.cpp b/bindings/Python/Generated/IR/MemRef/GenericAtomicRMWOp.cpp
deleted file mode 100644
index ce6c7ee94..000000000
--- a/bindings/Python/Generated/IR/MemRef/GenericAtomicRMWOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::GenericAtomicRMWOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1256]) || tp >= &(gTypes[1257])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::GenericAtomicRMWOp::static_kind():
-      tp = &(gTypes[1256]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GenericAtomicRMWOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "indices",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::indices);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GenericAtomicRMWOp::indices"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GenericAtomicRMWOp::result"),
-    nullptr,
-  },
-  {
-    "atomic_body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->atomic_body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GenericAtomicRMWOp::atomic_body"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::GenericAtomicRMWOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::GenericAtomicRMWOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::GenericAtomicRMWOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1256]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.GenericAtomicRMWOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::GenericAtomicRMWOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GenericAtomicRMWOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GenericAtomicRMWOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GenericAtomicRMWOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/GetGlobalOp.cpp b/bindings/Python/Generated/IR/MemRef/GetGlobalOp.cpp
deleted file mode 100644
index 55be1191e..000000000
--- a/bindings/Python/Generated/IR/MemRef/GetGlobalOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::GetGlobalOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1271]) || tp >= &(gTypes[1272])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::GetGlobalOp::static_kind():
-      tp = &(gTypes[1271]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GetGlobalOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GetGlobalOp::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::GetGlobalOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::GetGlobalOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::GetGlobalOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1271]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.GetGlobalOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::GetGlobalOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GetGlobalOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GetGlobalOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GetGlobalOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/GlobalOp.cpp b/bindings/Python/Generated/IR/MemRef/GlobalOp.cpp
deleted file mode 100644
index 287cd7e58..000000000
--- a/bindings/Python/Generated/IR/MemRef/GlobalOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::GlobalOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1272]) || tp >= &(gTypes[1273])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::GlobalOp::static_kind():
-      tp = &(gTypes[1272]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "GlobalOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GlobalOp::name"),
-    nullptr,
-  },
-  {
-    "visibility",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->visibility());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GlobalOp::visibility"),
-    nullptr,
-  },
-  {
-    "constant",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->constant());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GlobalOp::constant"),
-    nullptr,
-  },
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GlobalOp::alignment"),
-    nullptr,
-  },
-  {
-    "is_external",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_external());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GlobalOp::is_external"),
-    nullptr,
-  },
-  {
-    "is_uninitialized",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_uninitialized());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::GlobalOp::is_uninitialized"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::GlobalOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::GlobalOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::GlobalOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1272]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.GlobalOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::GlobalOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'GlobalOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'GlobalOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'GlobalOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/LoadOp.cpp b/bindings/Python/Generated/IR/MemRef/LoadOp.cpp
deleted file mode 100644
index f4252b832..000000000
--- a/bindings/Python/Generated/IR/MemRef/LoadOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::LoadOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1257]) || tp >= &(gTypes[1258])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::LoadOp::static_kind():
-      tp = &(gTypes[1257]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "LoadOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "indices",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::indices);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::LoadOp::indices"),
-    nullptr,
-  },
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::LoadOp::result"),
-    nullptr,
-  },
-  {
-    "nontemporal",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->nontemporal());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::LoadOp::nontemporal"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::LoadOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::LoadOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::LoadOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1257]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.LoadOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::LoadOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'LoadOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'LoadOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'LoadOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/MemorySpaceCastOp.cpp b/bindings/Python/Generated/IR/MemRef/MemorySpaceCastOp.cpp
deleted file mode 100644
index c455a1c7a..000000000
--- a/bindings/Python/Generated/IR/MemRef/MemorySpaceCastOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::MemorySpaceCastOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1273]) || tp >= &(gTypes[1274])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::MemorySpaceCastOp::static_kind():
-      tp = &(gTypes[1273]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "MemorySpaceCastOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::MemorySpaceCastOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::MemorySpaceCastOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::MemorySpaceCastOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1273]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.MemorySpaceCastOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::MemorySpaceCastOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'MemorySpaceCastOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'MemorySpaceCastOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'MemorySpaceCastOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/Operation.cpp b/bindings/Python/Generated/IR/MemRef/Operation.cpp
deleted file mode 100644
index 22b53e7b3..000000000
--- a/bindings/Python/Generated/IR/MemRef/Operation.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::Operation;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1251]) || tp >= &(gTypes[1283])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::AssumeAlignmentOp::static_kind():
-      tp = &(gTypes[1252]);
-      break;
-
-    case mx::ir::memref::AtomicRMWOp::static_kind():
-      tp = &(gTypes[1253]);
-      break;
-
-    case mx::ir::memref::AtomicYieldOp::static_kind():
-      tp = &(gTypes[1254]);
-      break;
-
-    case mx::ir::memref::CopyOp::static_kind():
-      tp = &(gTypes[1255]);
-      break;
-
-    case mx::ir::memref::GenericAtomicRMWOp::static_kind():
-      tp = &(gTypes[1256]);
-      break;
-
-    case mx::ir::memref::LoadOp::static_kind():
-      tp = &(gTypes[1257]);
-      break;
-
-    case mx::ir::memref::AllocOp::static_kind():
-      tp = &(gTypes[1258]);
-      break;
-
-    case mx::ir::memref::AllocaOp::static_kind():
-      tp = &(gTypes[1259]);
-      break;
-
-    case mx::ir::memref::AllocaScopeOp::static_kind():
-      tp = &(gTypes[1260]);
-      break;
-
-    case mx::ir::memref::AllocaScopeReturnOp::static_kind():
-      tp = &(gTypes[1261]);
-      break;
-
-    case mx::ir::memref::CastOp::static_kind():
-      tp = &(gTypes[1262]);
-      break;
-
-    case mx::ir::memref::CollapseShapeOp::static_kind():
-      tp = &(gTypes[1263]);
-      break;
-
-    case mx::ir::memref::DeallocOp::static_kind():
-      tp = &(gTypes[1264]);
-      break;
-
-    case mx::ir::memref::DimOp::static_kind():
-      tp = &(gTypes[1265]);
-      break;
-
-    case mx::ir::memref::DMAStartOp::static_kind():
-      tp = &(gTypes[1266]);
-      break;
-
-    case mx::ir::memref::DMAWaitOp::static_kind():
-      tp = &(gTypes[1267]);
-      break;
-
-    case mx::ir::memref::ExpandShapeOp::static_kind():
-      tp = &(gTypes[1268]);
-      break;
-
-    case mx::ir::memref::ExtractAlignedPointerAsIndexOp::static_kind():
-      tp = &(gTypes[1269]);
-      break;
-
-    case mx::ir::memref::ExtractStridedMetadataOp::static_kind():
-      tp = &(gTypes[1270]);
-      break;
-
-    case mx::ir::memref::GetGlobalOp::static_kind():
-      tp = &(gTypes[1271]);
-      break;
-
-    case mx::ir::memref::GlobalOp::static_kind():
-      tp = &(gTypes[1272]);
-      break;
-
-    case mx::ir::memref::MemorySpaceCastOp::static_kind():
-      tp = &(gTypes[1273]);
-      break;
-
-    case mx::ir::memref::PrefetchOp::static_kind():
-      tp = &(gTypes[1274]);
-      break;
-
-    case mx::ir::memref::RankOp::static_kind():
-      tp = &(gTypes[1275]);
-      break;
-
-    case mx::ir::memref::ReallocOp::static_kind():
-      tp = &(gTypes[1276]);
-      break;
-
-    case mx::ir::memref::ReinterpretCastOp::static_kind():
-      tp = &(gTypes[1277]);
-      break;
-
-    case mx::ir::memref::ReshapeOp::static_kind():
-      tp = &(gTypes[1278]);
-      break;
-
-    case mx::ir::memref::StoreOp::static_kind():
-      tp = &(gTypes[1279]);
-      break;
-
-    case mx::ir::memref::TransposeOp::static_kind():
-      tp = &(gTypes[1280]);
-      break;
-
-    case mx::ir::memref::ViewOp::static_kind():
-      tp = &(gTypes[1281]);
-      break;
-
-    case mx::ir::memref::SubViewOp::static_kind():
-      tp = &(gTypes[1282]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operation", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::Operation::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1251]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.Operation";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::Operation");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[998].tp_hash;
-  tp->tp_richcompare = gTypes[998].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[998]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operation.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operation.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operation' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/PrefetchOp.cpp b/bindings/Python/Generated/IR/MemRef/PrefetchOp.cpp
deleted file mode 100644
index dfcbac3eb..000000000
--- a/bindings/Python/Generated/IR/MemRef/PrefetchOp.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::PrefetchOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1274]) || tp >= &(gTypes[1275])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::PrefetchOp::static_kind():
-      tp = &(gTypes[1274]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "PrefetchOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "indices",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::indices);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::PrefetchOp::indices"),
-    nullptr,
-  },
-  {
-    "is_write",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_write());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::PrefetchOp::is_write"),
-    nullptr,
-  },
-  {
-    "locality_hint",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->locality_hint());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::PrefetchOp::locality_hint"),
-    nullptr,
-  },
-  {
-    "is_data_cache",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_data_cache());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::PrefetchOp::is_data_cache"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::PrefetchOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::PrefetchOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::PrefetchOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1274]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.PrefetchOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::PrefetchOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'PrefetchOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'PrefetchOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'PrefetchOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/RankOp.cpp b/bindings/Python/Generated/IR/MemRef/RankOp.cpp
deleted file mode 100644
index 320967e82..000000000
--- a/bindings/Python/Generated/IR/MemRef/RankOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::RankOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1275]) || tp >= &(gTypes[1276])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::RankOp::static_kind():
-      tp = &(gTypes[1275]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "RankOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::RankOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::RankOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::RankOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1275]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.RankOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::RankOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'RankOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'RankOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'RankOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/ReallocOp.cpp b/bindings/Python/Generated/IR/MemRef/ReallocOp.cpp
deleted file mode 100644
index 4f502aa3f..000000000
--- a/bindings/Python/Generated/IR/MemRef/ReallocOp.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::ReallocOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1276]) || tp >= &(gTypes[1277])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::ReallocOp::static_kind():
-      tp = &(gTypes[1276]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ReallocOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "alignment",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->alignment());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReallocOp::alignment"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReallocOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReallocOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReallocOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1276]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.ReallocOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::ReallocOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ReallocOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ReallocOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ReallocOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/ReinterpretCastOp.cpp b/bindings/Python/Generated/IR/MemRef/ReinterpretCastOp.cpp
deleted file mode 100644
index d6688d505..000000000
--- a/bindings/Python/Generated/IR/MemRef/ReinterpretCastOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::ReinterpretCastOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1277]) || tp >= &(gTypes[1278])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::ReinterpretCastOp::static_kind():
-      tp = &(gTypes[1277]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ReinterpretCastOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "offsets",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::offsets);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReinterpretCastOp::offsets"),
-    nullptr,
-  },
-  {
-    "sizes",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::sizes);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReinterpretCastOp::sizes"),
-    nullptr,
-  },
-  {
-    "strides",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::strides);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReinterpretCastOp::strides"),
-    nullptr,
-  },
-  {
-    "dynamic_sizes",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::dynamic_sizes);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReinterpretCastOp::dynamic_sizes"),
-    nullptr,
-  },
-  {
-    "result_rank",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result_rank());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReinterpretCastOp::result_rank"),
-    nullptr,
-  },
-  {
-    "offset_size_and_stride_start_operand_index",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->offset_size_and_stride_start_operand_index());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReinterpretCastOp::offset_size_and_stride_start_operand_index"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReinterpretCastOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReinterpretCastOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReinterpretCastOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1277]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.ReinterpretCastOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::ReinterpretCastOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ReinterpretCastOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ReinterpretCastOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ReinterpretCastOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/ReshapeOp.cpp b/bindings/Python/Generated/IR/MemRef/ReshapeOp.cpp
deleted file mode 100644
index 84eb66920..000000000
--- a/bindings/Python/Generated/IR/MemRef/ReshapeOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::ReshapeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1278]) || tp >= &(gTypes[1279])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::ReshapeOp::static_kind():
-      tp = &(gTypes[1278]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ReshapeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReshapeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReshapeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ReshapeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1278]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.ReshapeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::ReshapeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ReshapeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ReshapeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ReshapeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/StoreOp.cpp b/bindings/Python/Generated/IR/MemRef/StoreOp.cpp
deleted file mode 100644
index 7f7ec85d4..000000000
--- a/bindings/Python/Generated/IR/MemRef/StoreOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::StoreOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1279]) || tp >= &(gTypes[1280])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::StoreOp::static_kind():
-      tp = &(gTypes[1279]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "StoreOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::StoreOp::value"),
-    nullptr,
-  },
-  {
-    "indices",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::indices);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::StoreOp::indices"),
-    nullptr,
-  },
-  {
-    "nontemporal",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->nontemporal());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::StoreOp::nontemporal"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::StoreOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::StoreOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::StoreOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1279]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.StoreOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::StoreOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'StoreOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'StoreOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'StoreOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/SubViewOp.cpp b/bindings/Python/Generated/IR/MemRef/SubViewOp.cpp
deleted file mode 100644
index ff45f7b11..000000000
--- a/bindings/Python/Generated/IR/MemRef/SubViewOp.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::SubViewOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1282]) || tp >= &(gTypes[1283])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::SubViewOp::static_kind():
-      tp = &(gTypes[1282]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "SubViewOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "offsets",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::offsets);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::SubViewOp::offsets"),
-    nullptr,
-  },
-  {
-    "sizes",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::sizes);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::SubViewOp::sizes"),
-    nullptr,
-  },
-  {
-    "strides",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::strides);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::SubViewOp::strides"),
-    nullptr,
-  },
-  {
-    "view_source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->view_source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::SubViewOp::view_source"),
-    nullptr,
-  },
-  {
-    "dynamic_sizes",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::dynamic_sizes);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::SubViewOp::dynamic_sizes"),
-    nullptr,
-  },
-  {
-    "offset_size_and_stride_start_operand_index",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->offset_size_and_stride_start_operand_index());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::SubViewOp::offset_size_and_stride_start_operand_index"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::SubViewOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::SubViewOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::SubViewOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1282]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.SubViewOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::SubViewOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'SubViewOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'SubViewOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'SubViewOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/TransposeOp.cpp b/bindings/Python/Generated/IR/MemRef/TransposeOp.cpp
deleted file mode 100644
index e1d1bfaa1..000000000
--- a/bindings/Python/Generated/IR/MemRef/TransposeOp.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::TransposeOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1280]) || tp >= &(gTypes[1281])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::TransposeOp::static_kind():
-      tp = &(gTypes[1280]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "TransposeOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::TransposeOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::TransposeOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::TransposeOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1280]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.TransposeOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::TransposeOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'TransposeOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'TransposeOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'TransposeOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/MemRef/ViewOp.cpp b/bindings/Python/Generated/IR/MemRef/ViewOp.cpp
deleted file mode 100644
index 6662a3bcc..000000000
--- a/bindings/Python/Generated/IR/MemRef/ViewOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::memref::ViewOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1281]) || tp >= &(gTypes[1282])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::memref::ViewOp::static_kind():
-      tp = &(gTypes[1281]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "ViewOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "sizes",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::sizes);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ViewOp::sizes"),
-    nullptr,
-  },
-  {
-    "view_source",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->view_source());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::memref::ViewOp::view_source"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ViewOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ViewOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::memref::ViewOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1281]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.memref.ViewOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::memref::::ViewOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1251].tp_hash;
-  tp->tp_richcompare = gTypes[1251].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1251]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'ViewOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'ViewOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'ViewOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Meta/Attribute.cpp b/bindings/Python/Generated/IR/Meta/Attribute.cpp
deleted file mode 100644
index 9c22d8be4..000000000
--- a/bindings/Python/Generated/IR/Meta/Attribute.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Meta/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::meta::Attribute;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[991]) || tp >= &(gTypes[993])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::meta::IdentifierAttr::static_kind():
-      tp = &(gTypes[992]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Attribute", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::meta::Attribute::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[991]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.meta.Attribute";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::meta::::Attribute");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[867].tp_hash;
-  tp->tp_richcompare = gTypes[867].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[867]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Attribute.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Attribute.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Attribute' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Meta/IdentifierAttr.cpp b/bindings/Python/Generated/IR/Meta/IdentifierAttr.cpp
deleted file mode 100644
index 9e431b83a..000000000
--- a/bindings/Python/Generated/IR/Meta/IdentifierAttr.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Meta/Attribute.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::meta::IdentifierAttr;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[992]) || tp >= &(gTypes[993])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::meta::IdentifierAttr::static_kind():
-      tp = &(gTypes[992]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "IdentifierAttr", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::meta::IdentifierAttr::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Attribute>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::meta::IdentifierAttr::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[992]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.meta.IdentifierAttr";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::meta::::IdentifierAttr");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[991].tp_hash;
-  tp->tp_richcompare = gTypes[991].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[991]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'IdentifierAttr.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'IdentifierAttr.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'IdentifierAttr' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Operand.cpp b/bindings/Python/Generated/IR/Operand.cpp
deleted file mode 100644
index 0877488fb..000000000
--- a/bindings/Python/Generated/IR/Operand.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Operand;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1458]) || tp >= &(gTypes[1459])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  auto ret = gType->tp_alloc(gType, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operand", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "operation",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->operation());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operand::operation"),
-    nullptr,
-  },
-  {
-    "index",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->index());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operand::index"),
-    nullptr,
-  },
-  {
-    "value",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->value());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operand::value"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1458]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Operand";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Operand");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t {
-    return static_cast<Py_hash_t>(reinterpret_cast<uintptr_t>(T_cast(obj)->underlying_operand()));
-  };
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = nullptr;
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operand.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operand.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operand' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Operation.cpp b/bindings/Python/Generated/IR/Operation.cpp
deleted file mode 100644
index 731a7c618..000000000
--- a/bindings/Python/Generated/IR/Operation.cpp
+++ /dev/null
@@ -1,2428 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Operation;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[998]) || tp >= &(gTypes[1458])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::ModuleOp::static_kind():
-      tp = &(gTypes[1000]);
-      break;
-
-    case mx::ir::builtin::UnrealizedConversionCastOp::static_kind():
-      tp = &(gTypes[1001]);
-      break;
-
-    case mx::ir::llvm::AShrOp::static_kind():
-      tp = &(gTypes[1003]);
-      break;
-
-    case mx::ir::llvm::AddOp::static_kind():
-      tp = &(gTypes[1004]);
-      break;
-
-    case mx::ir::llvm::AddrSpaceCastOp::static_kind():
-      tp = &(gTypes[1005]);
-      break;
-
-    case mx::ir::llvm::AddressOfOp::static_kind():
-      tp = &(gTypes[1006]);
-      break;
-
-    case mx::ir::llvm::AllocaOp::static_kind():
-      tp = &(gTypes[1007]);
-      break;
-
-    case mx::ir::llvm::AndOp::static_kind():
-      tp = &(gTypes[1008]);
-      break;
-
-    case mx::ir::llvm::AtomicCmpXchgOp::static_kind():
-      tp = &(gTypes[1009]);
-      break;
-
-    case mx::ir::llvm::AtomicRMWOp::static_kind():
-      tp = &(gTypes[1010]);
-      break;
-
-    case mx::ir::llvm::BitcastOp::static_kind():
-      tp = &(gTypes[1011]);
-      break;
-
-    case mx::ir::llvm::BrOp::static_kind():
-      tp = &(gTypes[1012]);
-      break;
-
-    case mx::ir::llvm::CallIntrinsicOp::static_kind():
-      tp = &(gTypes[1013]);
-      break;
-
-    case mx::ir::llvm::CallOp::static_kind():
-      tp = &(gTypes[1014]);
-      break;
-
-    case mx::ir::llvm::ComdatOp::static_kind():
-      tp = &(gTypes[1015]);
-      break;
-
-    case mx::ir::llvm::ComdatSelectorOp::static_kind():
-      tp = &(gTypes[1016]);
-      break;
-
-    case mx::ir::llvm::CondBrOp::static_kind():
-      tp = &(gTypes[1017]);
-      break;
-
-    case mx::ir::llvm::ConstantOp::static_kind():
-      tp = &(gTypes[1018]);
-      break;
-
-    case mx::ir::llvm::ExtractElementOp::static_kind():
-      tp = &(gTypes[1019]);
-      break;
-
-    case mx::ir::llvm::ExtractValueOp::static_kind():
-      tp = &(gTypes[1020]);
-      break;
-
-    case mx::ir::llvm::FAddOp::static_kind():
-      tp = &(gTypes[1021]);
-      break;
-
-    case mx::ir::llvm::FCmpOp::static_kind():
-      tp = &(gTypes[1022]);
-      break;
-
-    case mx::ir::llvm::FDivOp::static_kind():
-      tp = &(gTypes[1023]);
-      break;
-
-    case mx::ir::llvm::FMulOp::static_kind():
-      tp = &(gTypes[1024]);
-      break;
-
-    case mx::ir::llvm::FNegOp::static_kind():
-      tp = &(gTypes[1025]);
-      break;
-
-    case mx::ir::llvm::FPExtOp::static_kind():
-      tp = &(gTypes[1026]);
-      break;
-
-    case mx::ir::llvm::FPToSIOp::static_kind():
-      tp = &(gTypes[1027]);
-      break;
-
-    case mx::ir::llvm::FPToUIOp::static_kind():
-      tp = &(gTypes[1028]);
-      break;
-
-    case mx::ir::llvm::FPTruncOp::static_kind():
-      tp = &(gTypes[1029]);
-      break;
-
-    case mx::ir::llvm::FRemOp::static_kind():
-      tp = &(gTypes[1030]);
-      break;
-
-    case mx::ir::llvm::FSubOp::static_kind():
-      tp = &(gTypes[1031]);
-      break;
-
-    case mx::ir::llvm::FenceOp::static_kind():
-      tp = &(gTypes[1032]);
-      break;
-
-    case mx::ir::llvm::FreezeOp::static_kind():
-      tp = &(gTypes[1033]);
-      break;
-
-    case mx::ir::llvm::GetElementPtrOp::static_kind():
-      tp = &(gTypes[1034]);
-      break;
-
-    case mx::ir::llvm::GlobalCtorsOp::static_kind():
-      tp = &(gTypes[1035]);
-      break;
-
-    case mx::ir::llvm::GlobalDtorsOp::static_kind():
-      tp = &(gTypes[1036]);
-      break;
-
-    case mx::ir::llvm::GlobalOp::static_kind():
-      tp = &(gTypes[1037]);
-      break;
-
-    case mx::ir::llvm::ICmpOp::static_kind():
-      tp = &(gTypes[1038]);
-      break;
-
-    case mx::ir::llvm::InlineAsmOp::static_kind():
-      tp = &(gTypes[1039]);
-      break;
-
-    case mx::ir::llvm::InsertElementOp::static_kind():
-      tp = &(gTypes[1040]);
-      break;
-
-    case mx::ir::llvm::InsertValueOp::static_kind():
-      tp = &(gTypes[1041]);
-      break;
-
-    case mx::ir::llvm::IntToPtrOp::static_kind():
-      tp = &(gTypes[1042]);
-      break;
-
-    case mx::ir::llvm::InvokeOp::static_kind():
-      tp = &(gTypes[1043]);
-      break;
-
-    case mx::ir::llvm::FuncOp::static_kind():
-      tp = &(gTypes[1044]);
-      break;
-
-    case mx::ir::llvm::LShrOp::static_kind():
-      tp = &(gTypes[1045]);
-      break;
-
-    case mx::ir::llvm::LandingpadOp::static_kind():
-      tp = &(gTypes[1046]);
-      break;
-
-    case mx::ir::llvm::LinkerOptionsOp::static_kind():
-      tp = &(gTypes[1047]);
-      break;
-
-    case mx::ir::llvm::LoadOp::static_kind():
-      tp = &(gTypes[1048]);
-      break;
-
-    case mx::ir::llvm::MulOp::static_kind():
-      tp = &(gTypes[1049]);
-      break;
-
-    case mx::ir::llvm::NoneTokenOp::static_kind():
-      tp = &(gTypes[1050]);
-      break;
-
-    case mx::ir::llvm::OrOp::static_kind():
-      tp = &(gTypes[1051]);
-      break;
-
-    case mx::ir::llvm::PoisonOp::static_kind():
-      tp = &(gTypes[1052]);
-      break;
-
-    case mx::ir::llvm::PtrToIntOp::static_kind():
-      tp = &(gTypes[1053]);
-      break;
-
-    case mx::ir::llvm::ResumeOp::static_kind():
-      tp = &(gTypes[1054]);
-      break;
-
-    case mx::ir::llvm::ReturnOp::static_kind():
-      tp = &(gTypes[1055]);
-      break;
-
-    case mx::ir::llvm::SDivOp::static_kind():
-      tp = &(gTypes[1056]);
-      break;
-
-    case mx::ir::llvm::SExtOp::static_kind():
-      tp = &(gTypes[1057]);
-      break;
-
-    case mx::ir::llvm::SIToFPOp::static_kind():
-      tp = &(gTypes[1058]);
-      break;
-
-    case mx::ir::llvm::SRemOp::static_kind():
-      tp = &(gTypes[1059]);
-      break;
-
-    case mx::ir::llvm::SelectOp::static_kind():
-      tp = &(gTypes[1060]);
-      break;
-
-    case mx::ir::llvm::ShlOp::static_kind():
-      tp = &(gTypes[1061]);
-      break;
-
-    case mx::ir::llvm::ShuffleVectorOp::static_kind():
-      tp = &(gTypes[1062]);
-      break;
-
-    case mx::ir::llvm::StoreOp::static_kind():
-      tp = &(gTypes[1063]);
-      break;
-
-    case mx::ir::llvm::SubOp::static_kind():
-      tp = &(gTypes[1064]);
-      break;
-
-    case mx::ir::llvm::SwitchOp::static_kind():
-      tp = &(gTypes[1065]);
-      break;
-
-    case mx::ir::llvm::TruncOp::static_kind():
-      tp = &(gTypes[1066]);
-      break;
-
-    case mx::ir::llvm::UDivOp::static_kind():
-      tp = &(gTypes[1067]);
-      break;
-
-    case mx::ir::llvm::UIToFPOp::static_kind():
-      tp = &(gTypes[1068]);
-      break;
-
-    case mx::ir::llvm::URemOp::static_kind():
-      tp = &(gTypes[1069]);
-      break;
-
-    case mx::ir::llvm::UndefOp::static_kind():
-      tp = &(gTypes[1070]);
-      break;
-
-    case mx::ir::llvm::UnreachableOp::static_kind():
-      tp = &(gTypes[1071]);
-      break;
-
-    case mx::ir::llvm::XOrOp::static_kind():
-      tp = &(gTypes[1072]);
-      break;
-
-    case mx::ir::llvm::ZExtOp::static_kind():
-      tp = &(gTypes[1073]);
-      break;
-
-    case mx::ir::llvm::ZeroOp::static_kind():
-      tp = &(gTypes[1074]);
-      break;
-
-    case mx::ir::llvm::AbsOp::static_kind():
-      tp = &(gTypes[1075]);
-      break;
-
-    case mx::ir::llvm::AnnotationOp::static_kind():
-      tp = &(gTypes[1076]);
-      break;
-
-    case mx::ir::llvm::AssumeOp::static_kind():
-      tp = &(gTypes[1077]);
-      break;
-
-    case mx::ir::llvm::BitReverseOp::static_kind():
-      tp = &(gTypes[1078]);
-      break;
-
-    case mx::ir::llvm::ByteSwapOp::static_kind():
-      tp = &(gTypes[1079]);
-      break;
-
-    case mx::ir::llvm::CopySignOp::static_kind():
-      tp = &(gTypes[1080]);
-      break;
-
-    case mx::ir::llvm::CoroAlignOp::static_kind():
-      tp = &(gTypes[1081]);
-      break;
-
-    case mx::ir::llvm::CoroBeginOp::static_kind():
-      tp = &(gTypes[1082]);
-      break;
-
-    case mx::ir::llvm::CoroEndOp::static_kind():
-      tp = &(gTypes[1083]);
-      break;
-
-    case mx::ir::llvm::CoroFreeOp::static_kind():
-      tp = &(gTypes[1084]);
-      break;
-
-    case mx::ir::llvm::CoroIdOp::static_kind():
-      tp = &(gTypes[1085]);
-      break;
-
-    case mx::ir::llvm::CoroPromiseOp::static_kind():
-      tp = &(gTypes[1086]);
-      break;
-
-    case mx::ir::llvm::CoroResumeOp::static_kind():
-      tp = &(gTypes[1087]);
-      break;
-
-    case mx::ir::llvm::CoroSaveOp::static_kind():
-      tp = &(gTypes[1088]);
-      break;
-
-    case mx::ir::llvm::CoroSizeOp::static_kind():
-      tp = &(gTypes[1089]);
-      break;
-
-    case mx::ir::llvm::CoroSuspendOp::static_kind():
-      tp = &(gTypes[1090]);
-      break;
-
-    case mx::ir::llvm::CosOp::static_kind():
-      tp = &(gTypes[1091]);
-      break;
-
-    case mx::ir::llvm::CountLeadingZerosOp::static_kind():
-      tp = &(gTypes[1092]);
-      break;
-
-    case mx::ir::llvm::CountTrailingZerosOp::static_kind():
-      tp = &(gTypes[1093]);
-      break;
-
-    case mx::ir::llvm::CtPopOp::static_kind():
-      tp = &(gTypes[1094]);
-      break;
-
-    case mx::ir::llvm::DbgDeclareOp::static_kind():
-      tp = &(gTypes[1095]);
-      break;
-
-    case mx::ir::llvm::DbgLabelOp::static_kind():
-      tp = &(gTypes[1096]);
-      break;
-
-    case mx::ir::llvm::DbgValueOp::static_kind():
-      tp = &(gTypes[1097]);
-      break;
-
-    case mx::ir::llvm::DebugTrapOp::static_kind():
-      tp = &(gTypes[1098]);
-      break;
-
-    case mx::ir::llvm::EhTypeidForOp::static_kind():
-      tp = &(gTypes[1099]);
-      break;
-
-    case mx::ir::llvm::Exp2Op::static_kind():
-      tp = &(gTypes[1100]);
-      break;
-
-    case mx::ir::llvm::ExpOp::static_kind():
-      tp = &(gTypes[1101]);
-      break;
-
-    case mx::ir::llvm::ExpectOp::static_kind():
-      tp = &(gTypes[1102]);
-      break;
-
-    case mx::ir::llvm::ExpectWithProbabilityOp::static_kind():
-      tp = &(gTypes[1103]);
-      break;
-
-    case mx::ir::llvm::FAbsOp::static_kind():
-      tp = &(gTypes[1104]);
-      break;
-
-    case mx::ir::llvm::FCeilOp::static_kind():
-      tp = &(gTypes[1105]);
-      break;
-
-    case mx::ir::llvm::FFloorOp::static_kind():
-      tp = &(gTypes[1106]);
-      break;
-
-    case mx::ir::llvm::FMAOp::static_kind():
-      tp = &(gTypes[1107]);
-      break;
-
-    case mx::ir::llvm::FMulAddOp::static_kind():
-      tp = &(gTypes[1108]);
-      break;
-
-    case mx::ir::llvm::FTruncOp::static_kind():
-      tp = &(gTypes[1109]);
-      break;
-
-    case mx::ir::llvm::FShlOp::static_kind():
-      tp = &(gTypes[1110]);
-      break;
-
-    case mx::ir::llvm::FShrOp::static_kind():
-      tp = &(gTypes[1111]);
-      break;
-
-    case mx::ir::llvm::GetActiveLaneMaskOp::static_kind():
-      tp = &(gTypes[1112]);
-      break;
-
-    case mx::ir::llvm::InvariantEndOp::static_kind():
-      tp = &(gTypes[1113]);
-      break;
-
-    case mx::ir::llvm::InvariantStartOp::static_kind():
-      tp = &(gTypes[1114]);
-      break;
-
-    case mx::ir::llvm::IsConstantOp::static_kind():
-      tp = &(gTypes[1115]);
-      break;
-
-    case mx::ir::llvm::IsFPClassOp::static_kind():
-      tp = &(gTypes[1116]);
-      break;
-
-    case mx::ir::llvm::LifetimeEndOp::static_kind():
-      tp = &(gTypes[1117]);
-      break;
-
-    case mx::ir::llvm::LifetimeStartOp::static_kind():
-      tp = &(gTypes[1118]);
-      break;
-
-    case mx::ir::llvm::RoundAndCastToLongLongOp::static_kind():
-      tp = &(gTypes[1119]);
-      break;
-
-    case mx::ir::llvm::RoundAndCastToNearestLongLongOp::static_kind():
-      tp = &(gTypes[1120]);
-      break;
-
-    case mx::ir::llvm::Log10Op::static_kind():
-      tp = &(gTypes[1121]);
-      break;
-
-    case mx::ir::llvm::Log2Op::static_kind():
-      tp = &(gTypes[1122]);
-      break;
-
-    case mx::ir::llvm::LogOp::static_kind():
-      tp = &(gTypes[1123]);
-      break;
-
-    case mx::ir::llvm::RoundAndCastToLongOp::static_kind():
-      tp = &(gTypes[1124]);
-      break;
-
-    case mx::ir::llvm::RoundAndCastToNearestLongOp::static_kind():
-      tp = &(gTypes[1125]);
-      break;
-
-    case mx::ir::llvm::MaskedLoadOp::static_kind():
-      tp = &(gTypes[1126]);
-      break;
-
-    case mx::ir::llvm::MaskedStoreOp::static_kind():
-      tp = &(gTypes[1127]);
-      break;
-
-    case mx::ir::llvm::MatrixColumnMajorLoadOp::static_kind():
-      tp = &(gTypes[1128]);
-      break;
-
-    case mx::ir::llvm::MatrixColumnMajorStoreOp::static_kind():
-      tp = &(gTypes[1129]);
-      break;
-
-    case mx::ir::llvm::MatrixMultiplyOp::static_kind():
-      tp = &(gTypes[1130]);
-      break;
-
-    case mx::ir::llvm::MatrixTransposeOp::static_kind():
-      tp = &(gTypes[1131]);
-      break;
-
-    case mx::ir::llvm::MaxNumOp::static_kind():
-      tp = &(gTypes[1132]);
-      break;
-
-    case mx::ir::llvm::MaximumOp::static_kind():
-      tp = &(gTypes[1133]);
-      break;
-
-    case mx::ir::llvm::MemcpyInlineOp::static_kind():
-      tp = &(gTypes[1134]);
-      break;
-
-    case mx::ir::llvm::MemcpyOp::static_kind():
-      tp = &(gTypes[1135]);
-      break;
-
-    case mx::ir::llvm::MemmoveOp::static_kind():
-      tp = &(gTypes[1136]);
-      break;
-
-    case mx::ir::llvm::MemsetOp::static_kind():
-      tp = &(gTypes[1137]);
-      break;
-
-    case mx::ir::llvm::MinNumOp::static_kind():
-      tp = &(gTypes[1138]);
-      break;
-
-    case mx::ir::llvm::MinimumOp::static_kind():
-      tp = &(gTypes[1139]);
-      break;
-
-    case mx::ir::llvm::RoundToNearbyIntOp::static_kind():
-      tp = &(gTypes[1140]);
-      break;
-
-    case mx::ir::llvm::NoAliasScopeDeclOp::static_kind():
-      tp = &(gTypes[1141]);
-      break;
-
-    case mx::ir::llvm::PowIOp::static_kind():
-      tp = &(gTypes[1142]);
-      break;
-
-    case mx::ir::llvm::FPowOp::static_kind():
-      tp = &(gTypes[1143]);
-      break;
-
-    case mx::ir::llvm::PrefetchOp::static_kind():
-      tp = &(gTypes[1144]);
-      break;
-
-    case mx::ir::llvm::PtrAnnotationOp::static_kind():
-      tp = &(gTypes[1145]);
-      break;
-
-    case mx::ir::llvm::RoundToIntOp::static_kind():
-      tp = &(gTypes[1146]);
-      break;
-
-    case mx::ir::llvm::RoundToNearestEvenOp::static_kind():
-      tp = &(gTypes[1147]);
-      break;
-
-    case mx::ir::llvm::RoundToNearestOp::static_kind():
-      tp = &(gTypes[1148]);
-      break;
-
-    case mx::ir::llvm::SAddSatOp::static_kind():
-      tp = &(gTypes[1149]);
-      break;
-
-    case mx::ir::llvm::SAddWithOverflowOp::static_kind():
-      tp = &(gTypes[1150]);
-      break;
-
-    case mx::ir::llvm::SMaxOp::static_kind():
-      tp = &(gTypes[1151]);
-      break;
-
-    case mx::ir::llvm::SMinOp::static_kind():
-      tp = &(gTypes[1152]);
-      break;
-
-    case mx::ir::llvm::SMulWithOverflowOp::static_kind():
-      tp = &(gTypes[1153]);
-      break;
-
-    case mx::ir::llvm::SSACopyOp::static_kind():
-      tp = &(gTypes[1154]);
-      break;
-
-    case mx::ir::llvm::SShlSatOp::static_kind():
-      tp = &(gTypes[1155]);
-      break;
-
-    case mx::ir::llvm::SSubSatOp::static_kind():
-      tp = &(gTypes[1156]);
-      break;
-
-    case mx::ir::llvm::SSubWithOverflowOp::static_kind():
-      tp = &(gTypes[1157]);
-      break;
-
-    case mx::ir::llvm::SinOp::static_kind():
-      tp = &(gTypes[1158]);
-      break;
-
-    case mx::ir::llvm::SqrtOp::static_kind():
-      tp = &(gTypes[1159]);
-      break;
-
-    case mx::ir::llvm::StackRestoreOp::static_kind():
-      tp = &(gTypes[1160]);
-      break;
-
-    case mx::ir::llvm::StackSaveOp::static_kind():
-      tp = &(gTypes[1161]);
-      break;
-
-    case mx::ir::llvm::StepVectorOp::static_kind():
-      tp = &(gTypes[1162]);
-      break;
-
-    case mx::ir::llvm::ThreadLocalAddressOp::static_kind():
-      tp = &(gTypes[1163]);
-      break;
-
-    case mx::ir::llvm::TrapOp::static_kind():
-      tp = &(gTypes[1164]);
-      break;
-
-    case mx::ir::llvm::UAddSatOp::static_kind():
-      tp = &(gTypes[1165]);
-      break;
-
-    case mx::ir::llvm::UAddWithOverflowOp::static_kind():
-      tp = &(gTypes[1166]);
-      break;
-
-    case mx::ir::llvm::UBSanTrapOp::static_kind():
-      tp = &(gTypes[1167]);
-      break;
-
-    case mx::ir::llvm::UMaxOp::static_kind():
-      tp = &(gTypes[1168]);
-      break;
-
-    case mx::ir::llvm::UMinOp::static_kind():
-      tp = &(gTypes[1169]);
-      break;
-
-    case mx::ir::llvm::UMulWithOverflowOp::static_kind():
-      tp = &(gTypes[1170]);
-      break;
-
-    case mx::ir::llvm::UShlSatOp::static_kind():
-      tp = &(gTypes[1171]);
-      break;
-
-    case mx::ir::llvm::USubSatOp::static_kind():
-      tp = &(gTypes[1172]);
-      break;
-
-    case mx::ir::llvm::USubWithOverflowOp::static_kind():
-      tp = &(gTypes[1173]);
-      break;
-
-    case mx::ir::llvm::VPAShrOp::static_kind():
-      tp = &(gTypes[1174]);
-      break;
-
-    case mx::ir::llvm::VPAddOp::static_kind():
-      tp = &(gTypes[1175]);
-      break;
-
-    case mx::ir::llvm::VPAndOp::static_kind():
-      tp = &(gTypes[1176]);
-      break;
-
-    case mx::ir::llvm::VPFAddOp::static_kind():
-      tp = &(gTypes[1177]);
-      break;
-
-    case mx::ir::llvm::VPFDivOp::static_kind():
-      tp = &(gTypes[1178]);
-      break;
-
-    case mx::ir::llvm::VPFMulAddOp::static_kind():
-      tp = &(gTypes[1179]);
-      break;
-
-    case mx::ir::llvm::VPFMulOp::static_kind():
-      tp = &(gTypes[1180]);
-      break;
-
-    case mx::ir::llvm::VPFNegOp::static_kind():
-      tp = &(gTypes[1181]);
-      break;
-
-    case mx::ir::llvm::VPFPExtOp::static_kind():
-      tp = &(gTypes[1182]);
-      break;
-
-    case mx::ir::llvm::VPFPToSIOp::static_kind():
-      tp = &(gTypes[1183]);
-      break;
-
-    case mx::ir::llvm::VPFPToUIOp::static_kind():
-      tp = &(gTypes[1184]);
-      break;
-
-    case mx::ir::llvm::VPFPTruncOp::static_kind():
-      tp = &(gTypes[1185]);
-      break;
-
-    case mx::ir::llvm::VPFRemOp::static_kind():
-      tp = &(gTypes[1186]);
-      break;
-
-    case mx::ir::llvm::VPFSubOp::static_kind():
-      tp = &(gTypes[1187]);
-      break;
-
-    case mx::ir::llvm::VPFmaOp::static_kind():
-      tp = &(gTypes[1188]);
-      break;
-
-    case mx::ir::llvm::VPIntToPtrOp::static_kind():
-      tp = &(gTypes[1189]);
-      break;
-
-    case mx::ir::llvm::VPLShrOp::static_kind():
-      tp = &(gTypes[1190]);
-      break;
-
-    case mx::ir::llvm::VPLoadOp::static_kind():
-      tp = &(gTypes[1191]);
-      break;
-
-    case mx::ir::llvm::VPMergeMinOp::static_kind():
-      tp = &(gTypes[1192]);
-      break;
-
-    case mx::ir::llvm::VPMulOp::static_kind():
-      tp = &(gTypes[1193]);
-      break;
-
-    case mx::ir::llvm::VPOrOp::static_kind():
-      tp = &(gTypes[1194]);
-      break;
-
-    case mx::ir::llvm::VPPtrToIntOp::static_kind():
-      tp = &(gTypes[1195]);
-      break;
-
-    case mx::ir::llvm::VPReduceAddOp::static_kind():
-      tp = &(gTypes[1196]);
-      break;
-
-    case mx::ir::llvm::VPReduceAndOp::static_kind():
-      tp = &(gTypes[1197]);
-      break;
-
-    case mx::ir::llvm::VPReduceFAddOp::static_kind():
-      tp = &(gTypes[1198]);
-      break;
-
-    case mx::ir::llvm::VPReduceFMaxOp::static_kind():
-      tp = &(gTypes[1199]);
-      break;
-
-    case mx::ir::llvm::VPReduceFMinOp::static_kind():
-      tp = &(gTypes[1200]);
-      break;
-
-    case mx::ir::llvm::VPReduceFMulOp::static_kind():
-      tp = &(gTypes[1201]);
-      break;
-
-    case mx::ir::llvm::VPReduceMulOp::static_kind():
-      tp = &(gTypes[1202]);
-      break;
-
-    case mx::ir::llvm::VPReduceOrOp::static_kind():
-      tp = &(gTypes[1203]);
-      break;
-
-    case mx::ir::llvm::VPReduceSMaxOp::static_kind():
-      tp = &(gTypes[1204]);
-      break;
-
-    case mx::ir::llvm::VPReduceSMinOp::static_kind():
-      tp = &(gTypes[1205]);
-      break;
-
-    case mx::ir::llvm::VPReduceUMaxOp::static_kind():
-      tp = &(gTypes[1206]);
-      break;
-
-    case mx::ir::llvm::VPReduceUMinOp::static_kind():
-      tp = &(gTypes[1207]);
-      break;
-
-    case mx::ir::llvm::VPReduceXorOp::static_kind():
-      tp = &(gTypes[1208]);
-      break;
-
-    case mx::ir::llvm::VPSDivOp::static_kind():
-      tp = &(gTypes[1209]);
-      break;
-
-    case mx::ir::llvm::VPSExtOp::static_kind():
-      tp = &(gTypes[1210]);
-      break;
-
-    case mx::ir::llvm::VPSIToFPOp::static_kind():
-      tp = &(gTypes[1211]);
-      break;
-
-    case mx::ir::llvm::VPSRemOp::static_kind():
-      tp = &(gTypes[1212]);
-      break;
-
-    case mx::ir::llvm::VPSelectMinOp::static_kind():
-      tp = &(gTypes[1213]);
-      break;
-
-    case mx::ir::llvm::VPShlOp::static_kind():
-      tp = &(gTypes[1214]);
-      break;
-
-    case mx::ir::llvm::VPStoreOp::static_kind():
-      tp = &(gTypes[1215]);
-      break;
-
-    case mx::ir::llvm::VPStridedLoadOp::static_kind():
-      tp = &(gTypes[1216]);
-      break;
-
-    case mx::ir::llvm::VPStridedStoreOp::static_kind():
-      tp = &(gTypes[1217]);
-      break;
-
-    case mx::ir::llvm::VPSubOp::static_kind():
-      tp = &(gTypes[1218]);
-      break;
-
-    case mx::ir::llvm::VPTruncOp::static_kind():
-      tp = &(gTypes[1219]);
-      break;
-
-    case mx::ir::llvm::VPUDivOp::static_kind():
-      tp = &(gTypes[1220]);
-      break;
-
-    case mx::ir::llvm::VPUIToFPOp::static_kind():
-      tp = &(gTypes[1221]);
-      break;
-
-    case mx::ir::llvm::VPURemOp::static_kind():
-      tp = &(gTypes[1222]);
-      break;
-
-    case mx::ir::llvm::VPXorOp::static_kind():
-      tp = &(gTypes[1223]);
-      break;
-
-    case mx::ir::llvm::VPZExtOp::static_kind():
-      tp = &(gTypes[1224]);
-      break;
-
-    case mx::ir::llvm::VaCopyOp::static_kind():
-      tp = &(gTypes[1225]);
-      break;
-
-    case mx::ir::llvm::VaEndOp::static_kind():
-      tp = &(gTypes[1226]);
-      break;
-
-    case mx::ir::llvm::VaStartOp::static_kind():
-      tp = &(gTypes[1227]);
-      break;
-
-    case mx::ir::llvm::VarAnnotationOp::static_kind():
-      tp = &(gTypes[1228]);
-      break;
-
-    case mx::ir::llvm::MaskedCompressStoreOp::static_kind():
-      tp = &(gTypes[1229]);
-      break;
-
-    case mx::ir::llvm::MaskedExpandLoadOp::static_kind():
-      tp = &(gTypes[1230]);
-      break;
-
-    case mx::ir::llvm::MaskedGatherOp::static_kind():
-      tp = &(gTypes[1231]);
-      break;
-
-    case mx::ir::llvm::MaskedScatterOp::static_kind():
-      tp = &(gTypes[1232]);
-      break;
-
-    case mx::ir::llvm::VectorExtractOp::static_kind():
-      tp = &(gTypes[1233]);
-      break;
-
-    case mx::ir::llvm::VectorInsertOp::static_kind():
-      tp = &(gTypes[1234]);
-      break;
-
-    case mx::ir::llvm::VectorReduceAddOp::static_kind():
-      tp = &(gTypes[1235]);
-      break;
-
-    case mx::ir::llvm::VectorReduceAndOp::static_kind():
-      tp = &(gTypes[1236]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFAddOp::static_kind():
-      tp = &(gTypes[1237]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMaxOp::static_kind():
-      tp = &(gTypes[1238]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMaximumOp::static_kind():
-      tp = &(gTypes[1239]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMinOp::static_kind():
-      tp = &(gTypes[1240]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMinimumOp::static_kind():
-      tp = &(gTypes[1241]);
-      break;
-
-    case mx::ir::llvm::VectorReduceFMulOp::static_kind():
-      tp = &(gTypes[1242]);
-      break;
-
-    case mx::ir::llvm::VectorReduceMulOp::static_kind():
-      tp = &(gTypes[1243]);
-      break;
-
-    case mx::ir::llvm::VectorReduceOrOp::static_kind():
-      tp = &(gTypes[1244]);
-      break;
-
-    case mx::ir::llvm::VectorReduceSMaxOp::static_kind():
-      tp = &(gTypes[1245]);
-      break;
-
-    case mx::ir::llvm::VectorReduceSMinOp::static_kind():
-      tp = &(gTypes[1246]);
-      break;
-
-    case mx::ir::llvm::VectorReduceUMaxOp::static_kind():
-      tp = &(gTypes[1247]);
-      break;
-
-    case mx::ir::llvm::VectorReduceUMinOp::static_kind():
-      tp = &(gTypes[1248]);
-      break;
-
-    case mx::ir::llvm::VectorReduceXorOp::static_kind():
-      tp = &(gTypes[1249]);
-      break;
-
-    case mx::ir::llvm::VScaleOp::static_kind():
-      tp = &(gTypes[1250]);
-      break;
-
-    case mx::ir::memref::AssumeAlignmentOp::static_kind():
-      tp = &(gTypes[1252]);
-      break;
-
-    case mx::ir::memref::AtomicRMWOp::static_kind():
-      tp = &(gTypes[1253]);
-      break;
-
-    case mx::ir::memref::AtomicYieldOp::static_kind():
-      tp = &(gTypes[1254]);
-      break;
-
-    case mx::ir::memref::CopyOp::static_kind():
-      tp = &(gTypes[1255]);
-      break;
-
-    case mx::ir::memref::GenericAtomicRMWOp::static_kind():
-      tp = &(gTypes[1256]);
-      break;
-
-    case mx::ir::memref::LoadOp::static_kind():
-      tp = &(gTypes[1257]);
-      break;
-
-    case mx::ir::memref::AllocOp::static_kind():
-      tp = &(gTypes[1258]);
-      break;
-
-    case mx::ir::memref::AllocaOp::static_kind():
-      tp = &(gTypes[1259]);
-      break;
-
-    case mx::ir::memref::AllocaScopeOp::static_kind():
-      tp = &(gTypes[1260]);
-      break;
-
-    case mx::ir::memref::AllocaScopeReturnOp::static_kind():
-      tp = &(gTypes[1261]);
-      break;
-
-    case mx::ir::memref::CastOp::static_kind():
-      tp = &(gTypes[1262]);
-      break;
-
-    case mx::ir::memref::CollapseShapeOp::static_kind():
-      tp = &(gTypes[1263]);
-      break;
-
-    case mx::ir::memref::DeallocOp::static_kind():
-      tp = &(gTypes[1264]);
-      break;
-
-    case mx::ir::memref::DimOp::static_kind():
-      tp = &(gTypes[1265]);
-      break;
-
-    case mx::ir::memref::DMAStartOp::static_kind():
-      tp = &(gTypes[1266]);
-      break;
-
-    case mx::ir::memref::DMAWaitOp::static_kind():
-      tp = &(gTypes[1267]);
-      break;
-
-    case mx::ir::memref::ExpandShapeOp::static_kind():
-      tp = &(gTypes[1268]);
-      break;
-
-    case mx::ir::memref::ExtractAlignedPointerAsIndexOp::static_kind():
-      tp = &(gTypes[1269]);
-      break;
-
-    case mx::ir::memref::ExtractStridedMetadataOp::static_kind():
-      tp = &(gTypes[1270]);
-      break;
-
-    case mx::ir::memref::GetGlobalOp::static_kind():
-      tp = &(gTypes[1271]);
-      break;
-
-    case mx::ir::memref::GlobalOp::static_kind():
-      tp = &(gTypes[1272]);
-      break;
-
-    case mx::ir::memref::MemorySpaceCastOp::static_kind():
-      tp = &(gTypes[1273]);
-      break;
-
-    case mx::ir::memref::PrefetchOp::static_kind():
-      tp = &(gTypes[1274]);
-      break;
-
-    case mx::ir::memref::RankOp::static_kind():
-      tp = &(gTypes[1275]);
-      break;
-
-    case mx::ir::memref::ReallocOp::static_kind():
-      tp = &(gTypes[1276]);
-      break;
-
-    case mx::ir::memref::ReinterpretCastOp::static_kind():
-      tp = &(gTypes[1277]);
-      break;
-
-    case mx::ir::memref::ReshapeOp::static_kind():
-      tp = &(gTypes[1278]);
-      break;
-
-    case mx::ir::memref::StoreOp::static_kind():
-      tp = &(gTypes[1279]);
-      break;
-
-    case mx::ir::memref::TransposeOp::static_kind():
-      tp = &(gTypes[1280]);
-      break;
-
-    case mx::ir::memref::ViewOp::static_kind():
-      tp = &(gTypes[1281]);
-      break;
-
-    case mx::ir::memref::SubViewOp::static_kind():
-      tp = &(gTypes[1282]);
-      break;
-
-    case mx::ir::abi::CallArgsOp::static_kind():
-      tp = &(gTypes[1284]);
-      break;
-
-    case mx::ir::abi::CallExecutionOp::static_kind():
-      tp = &(gTypes[1285]);
-      break;
-
-    case mx::ir::abi::CallOp::static_kind():
-      tp = &(gTypes[1286]);
-      break;
-
-    case mx::ir::abi::CallRetsOp::static_kind():
-      tp = &(gTypes[1287]);
-      break;
-
-    case mx::ir::abi::DirectOp::static_kind():
-      tp = &(gTypes[1288]);
-      break;
-
-    case mx::ir::abi::EpilogueOp::static_kind():
-      tp = &(gTypes[1289]);
-      break;
-
-    case mx::ir::abi::FuncOp::static_kind():
-      tp = &(gTypes[1290]);
-      break;
-
-    case mx::ir::abi::IndirectOp::static_kind():
-      tp = &(gTypes[1291]);
-      break;
-
-    case mx::ir::abi::PrologueOp::static_kind():
-      tp = &(gTypes[1292]);
-      break;
-
-    case mx::ir::abi::RetDirectOp::static_kind():
-      tp = &(gTypes[1293]);
-      break;
-
-    case mx::ir::abi::YieldOp::static_kind():
-      tp = &(gTypes[1294]);
-      break;
-
-    case mx::ir::ll::AllocaOp::static_kind():
-      tp = &(gTypes[1296]);
-      break;
-
-    case mx::ir::ll::ArgAllocaOp::static_kind():
-      tp = &(gTypes[1297]);
-      break;
-
-    case mx::ir::ll::BrOp::static_kind():
-      tp = &(gTypes[1298]);
-      break;
-
-    case mx::ir::ll::ConcatOp::static_kind():
-      tp = &(gTypes[1299]);
-      break;
-
-    case mx::ir::ll::CondBrOp::static_kind():
-      tp = &(gTypes[1300]);
-      break;
-
-    case mx::ir::ll::CondScopeRetOp::static_kind():
-      tp = &(gTypes[1301]);
-      break;
-
-    case mx::ir::ll::ExtractOp::static_kind():
-      tp = &(gTypes[1302]);
-      break;
-
-    case mx::ir::ll::InitializeVarOp::static_kind():
-      tp = &(gTypes[1303]);
-      break;
-
-    case mx::ir::ll::InlineScopeOp::static_kind():
-      tp = &(gTypes[1304]);
-      break;
-
-    case mx::ir::ll::LoadOp::static_kind():
-      tp = &(gTypes[1305]);
-      break;
-
-    case mx::ir::ll::FuncOp::static_kind():
-      tp = &(gTypes[1306]);
-      break;
-
-    case mx::ir::ll::StructGEPOp::static_kind():
-      tp = &(gTypes[1307]);
-      break;
-
-    case mx::ir::ll::ReturnOp::static_kind():
-      tp = &(gTypes[1308]);
-      break;
-
-    case mx::ir::ll::ScopeOp::static_kind():
-      tp = &(gTypes[1309]);
-      break;
-
-    case mx::ir::ll::ScopeRecurseOp::static_kind():
-      tp = &(gTypes[1310]);
-      break;
-
-    case mx::ir::ll::ScopeRetOp::static_kind():
-      tp = &(gTypes[1311]);
-      break;
-
-    case mx::ir::ll::StoreOp::static_kind():
-      tp = &(gTypes[1312]);
-      break;
-
-    case mx::ir::ll::SubscriptOp::static_kind():
-      tp = &(gTypes[1313]);
-      break;
-
-    case mx::ir::ll::UninitializedVarOp::static_kind():
-      tp = &(gTypes[1314]);
-      break;
-
-    case mx::ir::hl::DeclRefOp::static_kind():
-      tp = &(gTypes[1317]);
-      break;
-
-    case mx::ir::hl::EnumRefOp::static_kind():
-      tp = &(gTypes[1318]);
-      break;
-
-    case mx::ir::hl::FuncRefOp::static_kind():
-      tp = &(gTypes[1319]);
-      break;
-
-    case mx::ir::hl::GlobalRefOp::static_kind():
-      tp = &(gTypes[1320]);
-      break;
-
-    case mx::ir::hl::AccessSpecifierOp::static_kind():
-      tp = &(gTypes[1321]);
-      break;
-
-    case mx::ir::hl::AddFAssignOp::static_kind():
-      tp = &(gTypes[1322]);
-      break;
-
-    case mx::ir::hl::AddFOp::static_kind():
-      tp = &(gTypes[1323]);
-      break;
-
-    case mx::ir::hl::AddIAssignOp::static_kind():
-      tp = &(gTypes[1324]);
-      break;
-
-    case mx::ir::hl::AddIOp::static_kind():
-      tp = &(gTypes[1325]);
-      break;
-
-    case mx::ir::hl::AddrLabelExprOp::static_kind():
-      tp = &(gTypes[1326]);
-      break;
-
-    case mx::ir::hl::AddressOfOp::static_kind():
-      tp = &(gTypes[1327]);
-      break;
-
-    case mx::ir::hl::AlignOfExprOp::static_kind():
-      tp = &(gTypes[1328]);
-      break;
-
-    case mx::ir::hl::AlignOfTypeOp::static_kind():
-      tp = &(gTypes[1329]);
-      break;
-
-    case mx::ir::hl::AsmOp::static_kind():
-      tp = &(gTypes[1330]);
-      break;
-
-    case mx::ir::hl::AssignOp::static_kind():
-      tp = &(gTypes[1331]);
-      break;
-
-    case mx::ir::hl::AttributedStmtOp::static_kind():
-      tp = &(gTypes[1332]);
-      break;
-
-    case mx::ir::hl::BinAShrAssignOp::static_kind():
-      tp = &(gTypes[1333]);
-      break;
-
-    case mx::ir::hl::BinAShrOp::static_kind():
-      tp = &(gTypes[1334]);
-      break;
-
-    case mx::ir::hl::BinAndAssignOp::static_kind():
-      tp = &(gTypes[1335]);
-      break;
-
-    case mx::ir::hl::BinAndOp::static_kind():
-      tp = &(gTypes[1336]);
-      break;
-
-    case mx::ir::hl::BinCommaOp::static_kind():
-      tp = &(gTypes[1337]);
-      break;
-
-    case mx::ir::hl::BinLAndOp::static_kind():
-      tp = &(gTypes[1338]);
-      break;
-
-    case mx::ir::hl::BinLOrOp::static_kind():
-      tp = &(gTypes[1339]);
-      break;
-
-    case mx::ir::hl::BinLShrAssignOp::static_kind():
-      tp = &(gTypes[1340]);
-      break;
-
-    case mx::ir::hl::BinLShrOp::static_kind():
-      tp = &(gTypes[1341]);
-      break;
-
-    case mx::ir::hl::BinOrAssignOp::static_kind():
-      tp = &(gTypes[1342]);
-      break;
-
-    case mx::ir::hl::BinOrOp::static_kind():
-      tp = &(gTypes[1343]);
-      break;
-
-    case mx::ir::hl::BinShlAssignOp::static_kind():
-      tp = &(gTypes[1344]);
-      break;
-
-    case mx::ir::hl::BinShlOp::static_kind():
-      tp = &(gTypes[1345]);
-      break;
-
-    case mx::ir::hl::BinXorAssignOp::static_kind():
-      tp = &(gTypes[1346]);
-      break;
-
-    case mx::ir::hl::BinXorOp::static_kind():
-      tp = &(gTypes[1347]);
-      break;
-
-    case mx::ir::hl::BinaryCondOp::static_kind():
-      tp = &(gTypes[1348]);
-      break;
-
-    case mx::ir::hl::BreakOp::static_kind():
-      tp = &(gTypes[1349]);
-      break;
-
-    case mx::ir::hl::BuiltinBitCastOp::static_kind():
-      tp = &(gTypes[1350]);
-      break;
-
-    case mx::ir::hl::BuiltinTypesCompatiblePOp::static_kind():
-      tp = &(gTypes[1351]);
-      break;
-
-    case mx::ir::hl::CStyleCastOp::static_kind():
-      tp = &(gTypes[1352]);
-      break;
-
-    case mx::ir::hl::CallOp::static_kind():
-      tp = &(gTypes[1353]);
-      break;
-
-    case mx::ir::hl::CaseOp::static_kind():
-      tp = &(gTypes[1354]);
-      break;
-
-    case mx::ir::hl::ChooseExprOp::static_kind():
-      tp = &(gTypes[1355]);
-      break;
-
-    case mx::ir::hl::ClassDeclOp::static_kind():
-      tp = &(gTypes[1356]);
-      break;
-
-    case mx::ir::hl::CmpOp::static_kind():
-      tp = &(gTypes[1357]);
-      break;
-
-    case mx::ir::hl::CompoundLiteralOp::static_kind():
-      tp = &(gTypes[1358]);
-      break;
-
-    case mx::ir::hl::CondOp::static_kind():
-      tp = &(gTypes[1359]);
-      break;
-
-    case mx::ir::hl::CondYieldOp::static_kind():
-      tp = &(gTypes[1360]);
-      break;
-
-    case mx::ir::hl::ConstantOp::static_kind():
-      tp = &(gTypes[1361]);
-      break;
-
-    case mx::ir::hl::ContinueOp::static_kind():
-      tp = &(gTypes[1362]);
-      break;
-
-    case mx::ir::hl::CxxBaseSpecifierOp::static_kind():
-      tp = &(gTypes[1363]);
-      break;
-
-    case mx::ir::hl::CxxStructDeclOp::static_kind():
-      tp = &(gTypes[1364]);
-      break;
-
-    case mx::ir::hl::DefaultOp::static_kind():
-      tp = &(gTypes[1365]);
-      break;
-
-    case mx::ir::hl::DerefOp::static_kind():
-      tp = &(gTypes[1366]);
-      break;
-
-    case mx::ir::hl::DivFAssignOp::static_kind():
-      tp = &(gTypes[1367]);
-      break;
-
-    case mx::ir::hl::DivFOp::static_kind():
-      tp = &(gTypes[1368]);
-      break;
-
-    case mx::ir::hl::DivSAssignOp::static_kind():
-      tp = &(gTypes[1369]);
-      break;
-
-    case mx::ir::hl::DivSOp::static_kind():
-      tp = &(gTypes[1370]);
-      break;
-
-    case mx::ir::hl::DivUAssignOp::static_kind():
-      tp = &(gTypes[1371]);
-      break;
-
-    case mx::ir::hl::DivUOp::static_kind():
-      tp = &(gTypes[1372]);
-      break;
-
-    case mx::ir::hl::DoOp::static_kind():
-      tp = &(gTypes[1373]);
-      break;
-
-    case mx::ir::hl::EmptyDeclOp::static_kind():
-      tp = &(gTypes[1374]);
-      break;
-
-    case mx::ir::hl::EnumConstantOp::static_kind():
-      tp = &(gTypes[1375]);
-      break;
-
-    case mx::ir::hl::EnumDeclOp::static_kind():
-      tp = &(gTypes[1376]);
-      break;
-
-    case mx::ir::hl::ExprOp::static_kind():
-      tp = &(gTypes[1377]);
-      break;
-
-    case mx::ir::hl::ExtensionOp::static_kind():
-      tp = &(gTypes[1378]);
-      break;
-
-    case mx::ir::hl::FCmpOp::static_kind():
-      tp = &(gTypes[1379]);
-      break;
-
-    case mx::ir::hl::FieldDeclOp::static_kind():
-      tp = &(gTypes[1380]);
-      break;
-
-    case mx::ir::hl::FileScopeAsmOp::static_kind():
-      tp = &(gTypes[1381]);
-      break;
-
-    case mx::ir::hl::ForOp::static_kind():
-      tp = &(gTypes[1382]);
-      break;
-
-    case mx::ir::hl::FuncOp::static_kind():
-      tp = &(gTypes[1383]);
-      break;
-
-    case mx::ir::hl::GenericAssocExprOp::static_kind():
-      tp = &(gTypes[1384]);
-      break;
-
-    case mx::ir::hl::GenericSelectionExprOp::static_kind():
-      tp = &(gTypes[1385]);
-      break;
-
-    case mx::ir::hl::GotoStmtOp::static_kind():
-      tp = &(gTypes[1386]);
-      break;
-
-    case mx::ir::hl::IfOp::static_kind():
-      tp = &(gTypes[1387]);
-      break;
-
-    case mx::ir::hl::ImagOp::static_kind():
-      tp = &(gTypes[1388]);
-      break;
-
-    case mx::ir::hl::ImplicitCastOp::static_kind():
-      tp = &(gTypes[1389]);
-      break;
-
-    case mx::ir::hl::IndirectCallOp::static_kind():
-      tp = &(gTypes[1390]);
-      break;
-
-    case mx::ir::hl::IndirectGotoStmtOp::static_kind():
-      tp = &(gTypes[1391]);
-      break;
-
-    case mx::ir::hl::InitListExprOp::static_kind():
-      tp = &(gTypes[1392]);
-      break;
-
-    case mx::ir::hl::InitializedConstantOp::static_kind():
-      tp = &(gTypes[1393]);
-      break;
-
-    case mx::ir::hl::LNotOp::static_kind():
-      tp = &(gTypes[1394]);
-      break;
-
-    case mx::ir::hl::LabelDeclOp::static_kind():
-      tp = &(gTypes[1395]);
-      break;
-
-    case mx::ir::hl::LabelStmtOp::static_kind():
-      tp = &(gTypes[1396]);
-      break;
-
-    case mx::ir::hl::MinusOp::static_kind():
-      tp = &(gTypes[1397]);
-      break;
-
-    case mx::ir::hl::MulFAssignOp::static_kind():
-      tp = &(gTypes[1398]);
-      break;
-
-    case mx::ir::hl::MulFOp::static_kind():
-      tp = &(gTypes[1399]);
-      break;
-
-    case mx::ir::hl::MulIAssignOp::static_kind():
-      tp = &(gTypes[1400]);
-      break;
-
-    case mx::ir::hl::MulIOp::static_kind():
-      tp = &(gTypes[1401]);
-      break;
-
-    case mx::ir::hl::NotOp::static_kind():
-      tp = &(gTypes[1402]);
-      break;
-
-    case mx::ir::hl::NullStmtOp::static_kind():
-      tp = &(gTypes[1403]);
-      break;
-
-    case mx::ir::hl::OffsetOfExprOp::static_kind():
-      tp = &(gTypes[1404]);
-      break;
-
-    case mx::ir::hl::OpaqueValueExprOp::static_kind():
-      tp = &(gTypes[1405]);
-      break;
-
-    case mx::ir::hl::PlusOp::static_kind():
-      tp = &(gTypes[1406]);
-      break;
-
-    case mx::ir::hl::PostDecOp::static_kind():
-      tp = &(gTypes[1407]);
-      break;
-
-    case mx::ir::hl::PostIncOp::static_kind():
-      tp = &(gTypes[1408]);
-      break;
-
-    case mx::ir::hl::PreDecOp::static_kind():
-      tp = &(gTypes[1409]);
-      break;
-
-    case mx::ir::hl::PreIncOp::static_kind():
-      tp = &(gTypes[1410]);
-      break;
-
-    case mx::ir::hl::PredefinedExprOp::static_kind():
-      tp = &(gTypes[1411]);
-      break;
-
-    case mx::ir::hl::PreferredAlignOfExprOp::static_kind():
-      tp = &(gTypes[1412]);
-      break;
-
-    case mx::ir::hl::PreferredAlignOfTypeOp::static_kind():
-      tp = &(gTypes[1413]);
-      break;
-
-    case mx::ir::hl::RealOp::static_kind():
-      tp = &(gTypes[1414]);
-      break;
-
-    case mx::ir::hl::RecordMemberOp::static_kind():
-      tp = &(gTypes[1415]);
-      break;
-
-    case mx::ir::hl::RemFAssignOp::static_kind():
-      tp = &(gTypes[1416]);
-      break;
-
-    case mx::ir::hl::RemFOp::static_kind():
-      tp = &(gTypes[1417]);
-      break;
-
-    case mx::ir::hl::RemSAssignOp::static_kind():
-      tp = &(gTypes[1418]);
-      break;
-
-    case mx::ir::hl::RemSOp::static_kind():
-      tp = &(gTypes[1419]);
-      break;
-
-    case mx::ir::hl::RemUAssignOp::static_kind():
-      tp = &(gTypes[1420]);
-      break;
-
-    case mx::ir::hl::RemUOp::static_kind():
-      tp = &(gTypes[1421]);
-      break;
-
-    case mx::ir::hl::ReturnOp::static_kind():
-      tp = &(gTypes[1422]);
-      break;
-
-    case mx::ir::hl::SizeOfExprOp::static_kind():
-      tp = &(gTypes[1423]);
-      break;
-
-    case mx::ir::hl::SizeOfTypeOp::static_kind():
-      tp = &(gTypes[1424]);
-      break;
-
-    case mx::ir::hl::StaticAssertDeclOp::static_kind():
-      tp = &(gTypes[1425]);
-      break;
-
-    case mx::ir::hl::StmtExprOp::static_kind():
-      tp = &(gTypes[1426]);
-      break;
-
-    case mx::ir::hl::StructDeclOp::static_kind():
-      tp = &(gTypes[1427]);
-      break;
-
-    case mx::ir::hl::SubFAssignOp::static_kind():
-      tp = &(gTypes[1428]);
-      break;
-
-    case mx::ir::hl::SubFOp::static_kind():
-      tp = &(gTypes[1429]);
-      break;
-
-    case mx::ir::hl::SubIAssignOp::static_kind():
-      tp = &(gTypes[1430]);
-      break;
-
-    case mx::ir::hl::SubIOp::static_kind():
-      tp = &(gTypes[1431]);
-      break;
-
-    case mx::ir::hl::SubscriptOp::static_kind():
-      tp = &(gTypes[1432]);
-      break;
-
-    case mx::ir::hl::SwitchOp::static_kind():
-      tp = &(gTypes[1433]);
-      break;
-
-    case mx::ir::hl::ThisOp::static_kind():
-      tp = &(gTypes[1434]);
-      break;
-
-    case mx::ir::hl::TranslationUnitOp::static_kind():
-      tp = &(gTypes[1435]);
-      break;
-
-    case mx::ir::hl::TypeAliasOp::static_kind():
-      tp = &(gTypes[1436]);
-      break;
-
-    case mx::ir::hl::TypeDeclOp::static_kind():
-      tp = &(gTypes[1437]);
-      break;
-
-    case mx::ir::hl::TypeDefOp::static_kind():
-      tp = &(gTypes[1438]);
-      break;
-
-    case mx::ir::hl::TypeOfExprOp::static_kind():
-      tp = &(gTypes[1439]);
-      break;
-
-    case mx::ir::hl::TypeYieldOp::static_kind():
-      tp = &(gTypes[1440]);
-      break;
-
-    case mx::ir::hl::UnionDeclOp::static_kind():
-      tp = &(gTypes[1441]);
-      break;
-
-    case mx::ir::hl::UnreachableOp::static_kind():
-      tp = &(gTypes[1442]);
-      break;
-
-    case mx::ir::hl::VAArgExprOp::static_kind():
-      tp = &(gTypes[1443]);
-      break;
-
-    case mx::ir::hl::ValueYieldOp::static_kind():
-      tp = &(gTypes[1444]);
-      break;
-
-    case mx::ir::hl::VarDeclOp::static_kind():
-      tp = &(gTypes[1445]);
-      break;
-
-    case mx::ir::hl::WhileOp::static_kind():
-      tp = &(gTypes[1446]);
-      break;
-
-    case mx::ir::core::BinLAndOp::static_kind():
-      tp = &(gTypes[1448]);
-      break;
-
-    case mx::ir::core::BinLOrOp::static_kind():
-      tp = &(gTypes[1449]);
-      break;
-
-    case mx::ir::core::ImplicitReturnOp::static_kind():
-      tp = &(gTypes[1450]);
-      break;
-
-    case mx::ir::core::LazyOp::static_kind():
-      tp = &(gTypes[1451]);
-      break;
-
-    case mx::ir::core::ModuleOp::static_kind():
-      tp = &(gTypes[1452]);
-      break;
-
-    case mx::ir::core::ScopeOp::static_kind():
-      tp = &(gTypes[1453]);
-      break;
-
-    case mx::ir::core::SelectOp::static_kind():
-      tp = &(gTypes[1454]);
-      break;
-
-    case mx::ir::unsup::UnsupportedDeclOp::static_kind():
-      tp = &(gTypes[1456]);
-      break;
-
-    case mx::ir::unsup::UnsupportedStmtOp::static_kind():
-      tp = &(gTypes[1457]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operation", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "kind_name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->kind_name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::kind_name"),
-    nullptr,
-  },
-  {
-    "id",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->id());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::id"),
-    nullptr,
-  },
-  {
-    "kind",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->kind());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::kind"),
-    nullptr,
-  },
-  {
-    "num_operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_operands());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::num_operands"),
-    nullptr,
-  },
-  {
-    "operands",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::operands);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::operands"),
-    nullptr,
-  },
-  {
-    "num_results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_results());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::num_results"),
-    nullptr,
-  },
-  {
-    "results",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::results);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::results"),
-    nullptr,
-  },
-  {
-    "num_regions",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_regions());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::num_regions"),
-    nullptr,
-  },
-  {
-    "regions",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::regions);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::regions"),
-    nullptr,
-  },
-  {
-    "only_region",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->only_region());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::only_region"),
-    nullptr,
-  },
-  {
-    "only_region_blocks",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::only_region_blocks);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::only_region_blocks"),
-    nullptr,
-  },
-  {
-    "uses",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::uses);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::uses"),
-    nullptr,
-  },
-  {
-    "previous",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->previous());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::previous"),
-    nullptr,
-  },
-  {
-    "next",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->next());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::next"),
-    nullptr,
-  },
-  {
-    "is_terminator",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->is_terminator());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::is_terminator"),
-    nullptr,
-  },
-  {
-    "defined_symbol",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->defined_symbol());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Operation::defined_symbol"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "classify",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::string_view>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::classify(std::move(arg_0.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'classify'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Operation::classify"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Result>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Operation::producing"),
-  },
-  {
-    "containing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Region>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::containing(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Block>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::containing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'containing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Operation::containing"),
-  },
-  {
-    "first_from",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::first_from(arg_0.value()));
-          }
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<mx::ir::OperationKind>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::first_from(arg_0.value(), std::move(arg_1.value())));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::first_from(arg_0.value()));
-          }
-          while (num_args == 2) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-            auto arg_1 = ::mx::from_python<mx::ir::OperationKind>(args[1]);
-            if (!arg_1.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::first_from(arg_0.value(), std::move(arg_1.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'first_from'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Operation::first_from"),
-  },
-  {
-    "all_from",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Decl>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::all_from(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::Stmt>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::all_from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'all_from'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Operation::all_from"),
-  },
-  {
-    "defining",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Symbol>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::defining(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'defining'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Operation::defining"),
-  },
-  {
-    "nth_operand",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          T *obj = T_cast(self);
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<uint32_t>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(obj->nth_operand(std::move(arg_0.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'nth_operand'";
-          return nullptr;
-        }),
-    METH_FASTCALL,
-    PyDoc_STR("Wrapper for mx::ir::Operation::nth_operand"),
-  },
-  {
-    "nth_result",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          T *obj = T_cast(self);
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<uint32_t>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(obj->nth_result(std::move(arg_0.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'nth_result'";
-          return nullptr;
-        }),
-    METH_FASTCALL,
-    PyDoc_STR("Wrapper for mx::ir::Operation::nth_result"),
-  },
-  {
-    "nth_region",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          T *obj = T_cast(self);
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<uint32_t>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(obj->nth_region(std::move(arg_0.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'nth_region'";
-          return nullptr;
-        }),
-    METH_FASTCALL,
-    PyDoc_STR("Wrapper for mx::ir::Operation::nth_region"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[998]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Operation";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Operation");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t {
-    return static_cast<Py_hash_t>(EntityId(T_cast(obj)->id()).Pack());
-  };
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = PythonBinding<VariantEntity>::type();
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operation.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operation.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operation' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/OperationKind.cpp b/bindings/Python/Generated/IR/OperationKind.cpp
deleted file mode 100644
index d73dd64f5..000000000
--- a/bindings/Python/Generated/IR/OperationKind.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/OperationKind.h>
-#include <multiplier/Iterator.h>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-namespace mx {
-namespace {
-using T = mx::ir::OperationKind;
-}  // namespace
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  return PyObject_GetAttrString(reinterpret_cast<BorrowedPyObject *>(gType),
-                                EnumeratorName(val));
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  if (Py_TYPE(obj) != gType) {
-    return std::nullopt;
-  }
-
-  SharedPyPtr long_val(PyObject_GetAttrString(obj, "value"));
-  if (!long_val) {
-    PyErr_Clear();
-    return std::nullopt;
-  }
-
-  if (!PyLong_Check(long_val.Get())) {
-    return std::nullopt;
-  }
-
-  int did_overflow = 0;
-  const auto ret = static_cast<T>(
-      PyLong_AsLongLongAndOverflow(long_val.Get(), &did_overflow));
-  if (did_overflow) {
-    return std::nullopt;
-  }
-
-  return ret;
-}
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  const char * const enum_name = EnumerationName(T{});
-  bool created = false;
-
-  if (!gType) {
-    SharedPyPtr enum_module(PyImport_ImportModule("enum"));
-    if (!enum_module) {
-      return false;
-    }
-
-    SharedPyPtr int_enum(PyObject_GetAttrString(enum_module.Get(), "IntEnum"));
-    if (!int_enum) {
-      return false;
-    }
-
-    SharedPyPtr enum_meta(PyObject_Type(int_enum.Get()));
-    SharedPyPtr prepare(PyObject_GetAttrString(enum_meta.Get(), "__prepare__"));
-    if (!prepare) {
-      return false;
-    }
-
-    // Get the `enum._EnumDict` for what we're making.
-    SharedPyPtr ns_dict(PyObject_CallFunction(prepare.Get(), "s(O)", enum_name, int_enum.Get()));
-    if (!ns_dict) {
-      return false;
-    }
-
-    // Assign each enumerator.
-    for (T val : EnumerationRange<T>()) {
-      auto ival = PyLong_FromUnsignedLongLong(static_cast<uint64_t>(val));
-      if (ival) {
-        auto iname = PyUnicode_FromString(EnumeratorName(val));
-        if (!PyObject_SetItem(ns_dict, iname, ival)) {
-          continue;
-        }
-
-        Py_DECREF(iname);
-        Py_DECREF(ival);
-      }
-      return false;
-    }
-
-    // Create the type.
-    auto enum_class = PyObject_CallFunction(
-        enum_meta.Get(), "s(O)O", enum_name, int_enum.Get(), ns_dict.Get());
-    if (!enum_class) {
-      return false;
-    }
-
-    if (!PyType_Check(enum_class)) {
-      Py_DECREF(enum_class);
-
-      PyErrorStreamer(PyExc_ImportError)
-          << "Created enum class for enumerator '" << enum_name
-          << "' is not a python type";
-      return false;
-    }
-
-    gType = reinterpret_cast<PyTypeObject *>(enum_class);
-    created = true;
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, enum_name, tp_obj)) {
-    return false;
-  }
-
-  if (created) {
-    Py_DECREF(tp_obj);
-  }
-
-  return true;
-}
-
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Region.cpp b/bindings/Python/Generated/IR/Region.cpp
deleted file mode 100644
index 332a09c9d..000000000
--- a/bindings/Python/Generated/IR/Region.cpp
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Region.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Region;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1460]) || tp >= &(gTypes[1461])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  auto ret = gType->tp_alloc(gType, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Region", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "num_blocks",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_blocks());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Region::num_blocks"),
-    nullptr,
-  },
-  {
-    "blocks",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::blocks);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Region::blocks"),
-    nullptr,
-  },
-  {
-    "reverse_blocks",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::reverse_blocks);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Region::reverse_blocks"),
-    nullptr,
-  },
-  {
-    "entry_block",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->entry_block());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Region::entry_block"),
-    nullptr,
-  },
-  {
-    "num_entry_block_arguments",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->num_entry_block_arguments());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Region::num_entry_block_arguments"),
-    nullptr,
-  },
-  {
-    "entry_block_arguments",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::entry_block_arguments);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Region::entry_block_arguments"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "containing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Block>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::containing(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::containing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'containing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Region::containing"),
-  },
-  {
-    "nth_block",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          T *obj = T_cast(self);
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<uint32_t>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(obj->nth_block(std::move(arg_0.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'nth_block'";
-          return nullptr;
-        }),
-    METH_FASTCALL,
-    PyDoc_STR("Wrapper for mx::ir::Region::nth_block"),
-  },
-  {
-    "nth_entry_block_argument",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          T *obj = T_cast(self);
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<uint32_t>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(obj->nth_entry_block_argument(std::move(arg_0.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'nth_entry_block_argument'";
-          return nullptr;
-        }),
-    METH_FASTCALL,
-    PyDoc_STR("Wrapper for mx::ir::Region::nth_entry_block_argument"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1460]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Region";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Region");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t {
-    return static_cast<Py_hash_t>(reinterpret_cast<uintptr_t>(T_cast(obj)->underlying_region()));
-  };
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = nullptr;
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Region.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Region.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Region' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Result.cpp b/bindings/Python/Generated/IR/Result.cpp
deleted file mode 100644
index bfce5b365..000000000
--- a/bindings/Python/Generated/IR/Result.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Result;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[995]) || tp >= &(gTypes[996])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::Result::static_kind():
-      tp = &(gTypes[995]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Result", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "operation",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->operation());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Result::operation"),
-    nullptr,
-  },
-  {
-    "index",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->index());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Result::index"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Result::static_kind"),
-  },
-  {
-    "of",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::of(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'of'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Result::of"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Result::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[995]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Result";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Result");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[993].tp_hash;
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[993]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Result.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Result.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Result' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Symbol.cpp b/bindings/Python/Generated/IR/Symbol.cpp
deleted file mode 100644
index ef26ea1de..000000000
--- a/bindings/Python/Generated/IR/Symbol.cpp
+++ /dev/null
@@ -1,261 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Symbol;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1459]) || tp >= &(gTypes[1460])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  auto ret = gType->tp_alloc(gType, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Symbol", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "operation",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->operation());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Symbol::operation"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Symbol::name"),
-    nullptr,
-  },
-  {
-    "references",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::references);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Symbol::references"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::Symbol::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1459]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Symbol";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Symbol");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = PyObject_HashNotImplemented;
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = nullptr;
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Symbol.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Symbol.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Symbol' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Type.cpp b/bindings/Python/Generated/IR/Type.cpp
deleted file mode 100644
index 924719848..000000000
--- a/bindings/Python/Generated/IR/Type.cpp
+++ /dev/null
@@ -1,502 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1461]) || tp >= &(gTypes[1535])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::builtin::ShapedType::static_kind():
-      tp = &(gTypes[1463]);
-      break;
-
-    case mx::ir::builtin::FloatType::static_kind():
-      tp = &(gTypes[1464]);
-      break;
-
-    case mx::ir::builtin::ComplexType::static_kind():
-      tp = &(gTypes[1465]);
-      break;
-
-    case mx::ir::builtin::Float8E5M2Type::static_kind():
-      tp = &(gTypes[1466]);
-      break;
-
-    case mx::ir::builtin::Float8E4M3FNType::static_kind():
-      tp = &(gTypes[1467]);
-      break;
-
-    case mx::ir::builtin::Float8E5M2FNUZType::static_kind():
-      tp = &(gTypes[1468]);
-      break;
-
-    case mx::ir::builtin::Float8E4M3FNUZType::static_kind():
-      tp = &(gTypes[1469]);
-      break;
-
-    case mx::ir::builtin::Float8E4M3B11FNUZType::static_kind():
-      tp = &(gTypes[1470]);
-      break;
-
-    case mx::ir::builtin::BFloat16Type::static_kind():
-      tp = &(gTypes[1471]);
-      break;
-
-    case mx::ir::builtin::Float16Type::static_kind():
-      tp = &(gTypes[1472]);
-      break;
-
-    case mx::ir::builtin::FloatTF32Type::static_kind():
-      tp = &(gTypes[1473]);
-      break;
-
-    case mx::ir::builtin::Float32Type::static_kind():
-      tp = &(gTypes[1474]);
-      break;
-
-    case mx::ir::builtin::Float64Type::static_kind():
-      tp = &(gTypes[1475]);
-      break;
-
-    case mx::ir::builtin::Float80Type::static_kind():
-      tp = &(gTypes[1476]);
-      break;
-
-    case mx::ir::builtin::Float128Type::static_kind():
-      tp = &(gTypes[1477]);
-      break;
-
-    case mx::ir::builtin::FunctionType::static_kind():
-      tp = &(gTypes[1478]);
-      break;
-
-    case mx::ir::builtin::IndexType::static_kind():
-      tp = &(gTypes[1479]);
-      break;
-
-    case mx::ir::builtin::IntegerType::static_kind():
-      tp = &(gTypes[1480]);
-      break;
-
-    case mx::ir::builtin::MemRefType::static_kind():
-      tp = &(gTypes[1481]);
-      break;
-
-    case mx::ir::builtin::NoneType::static_kind():
-      tp = &(gTypes[1482]);
-      break;
-
-    case mx::ir::builtin::OpaqueType::static_kind():
-      tp = &(gTypes[1483]);
-      break;
-
-    case mx::ir::builtin::RankedTensorType::static_kind():
-      tp = &(gTypes[1484]);
-      break;
-
-    case mx::ir::builtin::TupleType::static_kind():
-      tp = &(gTypes[1485]);
-      break;
-
-    case mx::ir::builtin::UnrankedMemRefType::static_kind():
-      tp = &(gTypes[1486]);
-      break;
-
-    case mx::ir::builtin::UnrankedTensorType::static_kind():
-      tp = &(gTypes[1487]);
-      break;
-
-    case mx::ir::builtin::VectorType::static_kind():
-      tp = &(gTypes[1488]);
-      break;
-
-    case mx::ir::llvm::ArrayType::static_kind():
-      tp = &(gTypes[1490]);
-      break;
-
-    case mx::ir::llvm::FunctionType::static_kind():
-      tp = &(gTypes[1491]);
-      break;
-
-    case mx::ir::llvm::PointerType::static_kind():
-      tp = &(gTypes[1492]);
-      break;
-
-    case mx::ir::llvm::FixedVectorType::static_kind():
-      tp = &(gTypes[1493]);
-      break;
-
-    case mx::ir::llvm::ScalableVectorType::static_kind():
-      tp = &(gTypes[1494]);
-      break;
-
-    case mx::ir::llvm::TargetExtType::static_kind():
-      tp = &(gTypes[1495]);
-      break;
-
-    case mx::ir::hl::RecordType::static_kind():
-      tp = &(gTypes[1497]);
-      break;
-
-    case mx::ir::hl::EnumType::static_kind():
-      tp = &(gTypes[1498]);
-      break;
-
-    case mx::ir::hl::TypedefType::static_kind():
-      tp = &(gTypes[1499]);
-      break;
-
-    case mx::ir::hl::ElaboratedType::static_kind():
-      tp = &(gTypes[1500]);
-      break;
-
-    case mx::ir::hl::LabelType::static_kind():
-      tp = &(gTypes[1501]);
-      break;
-
-    case mx::ir::hl::ParenType::static_kind():
-      tp = &(gTypes[1502]);
-      break;
-
-    case mx::ir::hl::LValueType::static_kind():
-      tp = &(gTypes[1503]);
-      break;
-
-    case mx::ir::hl::RValueType::static_kind():
-      tp = &(gTypes[1504]);
-      break;
-
-    case mx::ir::hl::VoidType::static_kind():
-      tp = &(gTypes[1505]);
-      break;
-
-    case mx::ir::hl::BoolType::static_kind():
-      tp = &(gTypes[1506]);
-      break;
-
-    case mx::ir::hl::CharType::static_kind():
-      tp = &(gTypes[1507]);
-      break;
-
-    case mx::ir::hl::ShortType::static_kind():
-      tp = &(gTypes[1508]);
-      break;
-
-    case mx::ir::hl::IntType::static_kind():
-      tp = &(gTypes[1509]);
-      break;
-
-    case mx::ir::hl::LongType::static_kind():
-      tp = &(gTypes[1510]);
-      break;
-
-    case mx::ir::hl::LongLongType::static_kind():
-      tp = &(gTypes[1511]);
-      break;
-
-    case mx::ir::hl::Int128Type::static_kind():
-      tp = &(gTypes[1512]);
-      break;
-
-    case mx::ir::hl::HalfType::static_kind():
-      tp = &(gTypes[1513]);
-      break;
-
-    case mx::ir::hl::BFloat16Type::static_kind():
-      tp = &(gTypes[1514]);
-      break;
-
-    case mx::ir::hl::FloatType::static_kind():
-      tp = &(gTypes[1515]);
-      break;
-
-    case mx::ir::hl::DoubleType::static_kind():
-      tp = &(gTypes[1516]);
-      break;
-
-    case mx::ir::hl::LongDoubleType::static_kind():
-      tp = &(gTypes[1517]);
-      break;
-
-    case mx::ir::hl::Float128Type::static_kind():
-      tp = &(gTypes[1518]);
-      break;
-
-    case mx::ir::hl::ComplexType::static_kind():
-      tp = &(gTypes[1519]);
-      break;
-
-    case mx::ir::hl::PointerType::static_kind():
-      tp = &(gTypes[1520]);
-      break;
-
-    case mx::ir::hl::ArrayType::static_kind():
-      tp = &(gTypes[1521]);
-      break;
-
-    case mx::ir::hl::VectorType::static_kind():
-      tp = &(gTypes[1522]);
-      break;
-
-    case mx::ir::hl::DecayedType::static_kind():
-      tp = &(gTypes[1523]);
-      break;
-
-    case mx::ir::hl::AttributedType::static_kind():
-      tp = &(gTypes[1524]);
-      break;
-
-    case mx::ir::hl::AdjustedType::static_kind():
-      tp = &(gTypes[1525]);
-      break;
-
-    case mx::ir::hl::ReferenceType::static_kind():
-      tp = &(gTypes[1526]);
-      break;
-
-    case mx::ir::hl::TypeOfExprType::static_kind():
-      tp = &(gTypes[1527]);
-      break;
-
-    case mx::ir::hl::TypeOfTypeType::static_kind():
-      tp = &(gTypes[1528]);
-      break;
-
-    case mx::ir::hl::AutoType::static_kind():
-      tp = &(gTypes[1529]);
-      break;
-
-    case mx::ir::hl::AtomicType::static_kind():
-      tp = &(gTypes[1530]);
-      break;
-
-    case mx::ir::core::FunctionType::static_kind():
-      tp = &(gTypes[1532]);
-      break;
-
-    case mx::ir::unsup::UnsupportedType::static_kind():
-      tp = &(gTypes[1534]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "kind",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->kind());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Type::kind"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1461]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t {
-    return static_cast<Py_hash_t>(reinterpret_cast<uintptr_t>(T_cast(obj)->underlying_type()));
-  };
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = nullptr;
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/TypeKind.cpp b/bindings/Python/Generated/IR/TypeKind.cpp
deleted file mode 100644
index 7e9fdeb83..000000000
--- a/bindings/Python/Generated/IR/TypeKind.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/TypeKind.h>
-#include <multiplier/Iterator.h>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-namespace mx {
-namespace {
-using T = mx::ir::TypeKind;
-}  // namespace
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  return PyObject_GetAttrString(reinterpret_cast<BorrowedPyObject *>(gType),
-                                EnumeratorName(val));
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  if (Py_TYPE(obj) != gType) {
-    return std::nullopt;
-  }
-
-  SharedPyPtr long_val(PyObject_GetAttrString(obj, "value"));
-  if (!long_val) {
-    PyErr_Clear();
-    return std::nullopt;
-  }
-
-  if (!PyLong_Check(long_val.Get())) {
-    return std::nullopt;
-  }
-
-  int did_overflow = 0;
-  const auto ret = static_cast<T>(
-      PyLong_AsLongLongAndOverflow(long_val.Get(), &did_overflow));
-  if (did_overflow) {
-    return std::nullopt;
-  }
-
-  return ret;
-}
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  const char * const enum_name = EnumerationName(T{});
-  bool created = false;
-
-  if (!gType) {
-    SharedPyPtr enum_module(PyImport_ImportModule("enum"));
-    if (!enum_module) {
-      return false;
-    }
-
-    SharedPyPtr int_enum(PyObject_GetAttrString(enum_module.Get(), "IntEnum"));
-    if (!int_enum) {
-      return false;
-    }
-
-    SharedPyPtr enum_meta(PyObject_Type(int_enum.Get()));
-    SharedPyPtr prepare(PyObject_GetAttrString(enum_meta.Get(), "__prepare__"));
-    if (!prepare) {
-      return false;
-    }
-
-    // Get the `enum._EnumDict` for what we're making.
-    SharedPyPtr ns_dict(PyObject_CallFunction(prepare.Get(), "s(O)", enum_name, int_enum.Get()));
-    if (!ns_dict) {
-      return false;
-    }
-
-    // Assign each enumerator.
-    for (T val : EnumerationRange<T>()) {
-      auto ival = PyLong_FromUnsignedLongLong(static_cast<uint64_t>(val));
-      if (ival) {
-        auto iname = PyUnicode_FromString(EnumeratorName(val));
-        if (!PyObject_SetItem(ns_dict, iname, ival)) {
-          continue;
-        }
-
-        Py_DECREF(iname);
-        Py_DECREF(ival);
-      }
-      return false;
-    }
-
-    // Create the type.
-    auto enum_class = PyObject_CallFunction(
-        enum_meta.Get(), "s(O)O", enum_name, int_enum.Get(), ns_dict.Get());
-    if (!enum_class) {
-      return false;
-    }
-
-    if (!PyType_Check(enum_class)) {
-      Py_DECREF(enum_class);
-
-      PyErrorStreamer(PyExc_ImportError)
-          << "Created enum class for enumerator '" << enum_name
-          << "' is not a python type";
-      return false;
-    }
-
-    gType = reinterpret_cast<PyTypeObject *>(enum_class);
-    created = true;
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, enum_name, tp_obj)) {
-    return false;
-  }
-
-  if (created) {
-    Py_DECREF(tp_obj);
-  }
-
-  return true;
-}
-
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Unsupported/Operation.cpp b/bindings/Python/Generated/IR/Unsupported/Operation.cpp
deleted file mode 100644
index d11f9f103..000000000
--- a/bindings/Python/Generated/IR/Unsupported/Operation.cpp
+++ /dev/null
@@ -1,221 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Unsupported/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::unsup::Operation;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1455]) || tp >= &(gTypes[1458])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::unsup::UnsupportedDeclOp::static_kind():
-      tp = &(gTypes[1456]);
-      break;
-
-    case mx::ir::unsup::UnsupportedStmtOp::static_kind():
-      tp = &(gTypes[1457]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Operation", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::Operation::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1455]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.unsupported.Operation";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::unsup::::Operation");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[998].tp_hash;
-  tp->tp_richcompare = gTypes[998].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[998]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Operation.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Operation.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Operation' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Unsupported/Type.cpp b/bindings/Python/Generated/IR/Unsupported/Type.cpp
deleted file mode 100644
index c6110d7a0..000000000
--- a/bindings/Python/Generated/IR/Unsupported/Type.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Unsupported/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::unsup::Type;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1533]) || tp >= &(gTypes[1535])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::unsup::UnsupportedType::static_kind():
-      tp = &(gTypes[1534]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Type", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::Type::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1533]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.unsupported.Type";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::unsup::::Type");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1461].tp_hash;
-  tp->tp_richcompare = gTypes[1461].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1461]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Type.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Type.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Type' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Unsupported/UnsupportedDeclOp.cpp b/bindings/Python/Generated/IR/Unsupported/UnsupportedDeclOp.cpp
deleted file mode 100644
index b6db2ec06..000000000
--- a/bindings/Python/Generated/IR/Unsupported/UnsupportedDeclOp.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Unsupported/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::unsup::UnsupportedDeclOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1456]) || tp >= &(gTypes[1457])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::unsup::UnsupportedDeclOp::static_kind():
-      tp = &(gTypes[1456]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnsupportedDeclOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "body",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->body());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedDeclOp::body"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedDeclOp::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedDeclOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedDeclOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedDeclOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1456]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.unsupported.UnsupportedDeclOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::unsup::::UnsupportedDeclOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1455].tp_hash;
-  tp->tp_richcompare = gTypes[1455].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1455]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnsupportedDeclOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnsupportedDeclOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnsupportedDeclOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Unsupported/UnsupportedStmtOp.cpp b/bindings/Python/Generated/IR/Unsupported/UnsupportedStmtOp.cpp
deleted file mode 100644
index e3d1e13e1..000000000
--- a/bindings/Python/Generated/IR/Unsupported/UnsupportedStmtOp.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Unsupported/Operation.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::unsup::UnsupportedStmtOp;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1457]) || tp >= &(gTypes[1458])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::unsup::UnsupportedStmtOp::static_kind():
-      tp = &(gTypes[1457]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnsupportedStmtOp", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "result",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->result());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedStmtOp::result"),
-    nullptr,
-  },
-  {
-    "children",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::children);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedStmtOp::children"),
-    nullptr,
-  },
-  {
-    "name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedStmtOp::name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedStmtOp::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedStmtOp::from"),
-  },
-  {
-    "producing",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Value>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::producing(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'producing'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedStmtOp::producing"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1457]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.unsupported.UnsupportedStmtOp";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::unsup::::UnsupportedStmtOp");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1455].tp_hash;
-  tp->tp_richcompare = gTypes[1455].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1455]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnsupportedStmtOp.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnsupportedStmtOp.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnsupportedStmtOp' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Unsupported/UnsupportedType.cpp b/bindings/Python/Generated/IR/Unsupported/UnsupportedType.cpp
deleted file mode 100644
index 9c025a531..000000000
--- a/bindings/Python/Generated/IR/Unsupported/UnsupportedType.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Unsupported/Type.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::unsup::UnsupportedType;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1534]) || tp >= &(gTypes[1535])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::unsup::UnsupportedType::static_kind():
-      tp = &(gTypes[1534]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "UnsupportedType", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "origin_name",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->origin_name());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedType::origin_name"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {
-    "static_kind",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 0) {
-
-            return ::mx::to_python(T::static_kind());
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'static_kind'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedType::static_kind"),
-  },
-  {
-    "FROM",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Type>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::from(arg_0.value()));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'FROM'";
-          return nullptr;
-        }),
-    METH_FASTCALL | METH_STATIC,
-    PyDoc_STR("Wrapper for mx::ir::unsup::UnsupportedType::from"),
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1534]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.unsupported.UnsupportedType";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::unsup::::UnsupportedType");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = gTypes[1533].tp_hash;
-  tp->tp_richcompare = gTypes[1533].tp_richcompare;
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = &(gTypes[1533]);
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'UnsupportedType.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'UnsupportedType.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'UnsupportedType' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/Value.cpp b/bindings/Python/Generated/IR/Value.cpp
deleted file mode 100644
index 2e97c1b4d..000000000
--- a/bindings/Python/Generated/IR/Value.cpp
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Value.h>
-
-#include <multiplier/AST.h>
-#include <multiplier/Fragment.h>
-#include <multiplier/Frontend.h>
-#include <multiplier/Index.h>
-#include <multiplier/IR.h>
-#include <multiplier/Re2.h>
-
-#include <cassert>
-#include <new>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wc99-extensions"
-#pragma GCC diagnostic ignored "-Wunused-function"
-namespace {
-using T = mx::ir::Value;
-
-struct O final : public ::PyObject {
-
-  // When initialized, points to `backing_storage`.
-  T *data{nullptr};
-
-  // Aligned storage for `T`. Pointed to by `data`.
-  alignas(alignof(T)) char backing_storage[sizeof(T)];  
-};
-
-inline static O *O_cast(void *obj) noexcept {
-  return reinterpret_cast<O *>(obj);
-}
-
-inline static const O *O_cast(const void *obj) noexcept {
-  return reinterpret_cast<const O *>(obj);
-}
-
-inline static T *T_cast(void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-inline static const T *T_cast(const void *obj) noexcept {
-  return O_cast(obj)->data;
-}
-
-}  // namespace
-namespace mx {
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[993]) || tp >= &(gTypes[996])) {
-    return std::nullopt;
-  }
-
-  return *T_cast(obj);
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  PyTypeObject *tp = nullptr;
-  switch (val.kind()) {
-    default:
-      assert(false);
-      tp = gType;
-      break;
-
-    case mx::ir::Argument::static_kind():
-      tp = &(gTypes[994]);
-      break;
-
-    case mx::ir::Result::static_kind():
-      tp = &(gTypes[995]);
-      break;
-
-  }
-  auto ret = tp->tp_alloc(tp, 0);
-  if (auto obj = O_cast(ret)) {
-    obj->data = new (obj->backing_storage) T(std::move(val));
-  }
-  return ret;
-}
-
-namespace {
-static PyTypeObject *InitType(void) noexcept;
-}  // namespace
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  if (!gType) {
-    gType = InitType();
-    if (!gType) {
-      return false;
-    }
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, "Value", tp_obj)) {
-    return false;
-  }
-
-  return true;
-}
-
-namespace {
-static PyGetSetDef gProperties[] = {
-  {
-    "kind",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->kind());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Value::kind"),
-    nullptr,
-  },
-  {
-    "type",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->type());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Value::type"),
-    nullptr,
-  },
-  {
-    "uses",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::generator_to_python(*T_cast(self), &T::uses);
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::ir::Value::uses"),
-    nullptr,
-  },
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-static PyMethodDef gMethods[] = {
-  {}  // Sentinel.
-};
-}  // namespace
-
-namespace {
-
-PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[993]);
-  tp->tp_basicsize = sizeof(O);
-  tp->tp_itemsize = 0;
-  tp->tp_dealloc = [] (::PyObject *obj) {
-    if (auto *data = T_cast(obj)) {
-      data->~T();
-    }
-    PyObject_Free(obj);
-  };
-  tp->tp_name = "multiplier.ir.Value";
-  tp->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION;
-  tp->tp_doc = PyDoc_STR("Wrapper for mx::ir::::Value");
-  tp->tp_as_number = nullptr;
-  tp->tp_as_sequence = nullptr;
-  tp->tp_as_mapping = nullptr;
-  tp->tp_hash = [] (BorrowedPyObject *obj) -> Py_hash_t {
-    return static_cast<Py_hash_t>(reinterpret_cast<uintptr_t>(T_cast(obj)->underlying_value()));
-  };
-  tp->tp_richcompare = [] (BorrowedPyObject *a_obj, BorrowedPyObject *b_obj, int op) -> SharedPyObject * {
-    do {
-      if (Py_EQ != op && Py_NE != op) {
-        break;
-      }
-
-      auto a = ::mx::from_python<T>(a_obj);
-      if (!a.has_value()) {
-        break;
-      }
-
-      auto b = ::mx::from_python<T>(b_obj);
-      if (!b.has_value()) {
-        break;
-      }
-
-      auto ret = (a.value() == b.value()) == (Py_EQ == op) ? Py_True : Py_False;
-      Py_INCREF(ret);
-      return ret;
-    } while (false);
-
-    static constexpr const char *kOperators[] = {"<", "<=", "==", "!=", ">", ">="};
-    PyErrorStreamer(PyExc_TypeError)
-        << "'" << kOperators[op] << "' not supported between instances of '"
-        << Py_TYPE(a_obj)->tp_name << "' and '" << Py_TYPE(b_obj)->tp_name << "'";
-    return nullptr;
-  };
-  tp->tp_iter = nullptr;
-  tp->tp_methods = gMethods;
-  tp->tp_getset = gProperties;
-  tp->tp_base = nullptr;
-  tp->tp_init = [] (BorrowedPyObject *self, BorrowedPyObject *args, BorrowedPyObject *kwargs) -> int {
-    if (kwargs && (!PyMapping_Check(kwargs) || PyMapping_Size(kwargs))) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "'Value.__init__' does not take any keyword arguments";
-      return -1;
-    }
-
-    if (!args || !PySequence_Check(args)) {
-      PyErrorStreamer(PyExc_TypeError)
-          << "Invalid positional arguments passed to 'Value.__init__'";
-      return -1;
-    }
-
-    auto obj = O_cast(self);
-    auto num_args = PySequence_Size(args);
-    
-    (void) obj;
-    (void) num_args;
-    PyErrorStreamer(PyExc_TypeError)
-        << "Class 'Value' cannot be directly instantiated";
-    return -1;
-
-  };
-  tp->tp_alloc = PyType_GenericAlloc;
-  tp->tp_new = nullptr;
-
-  if (0 != PyType_Ready(tp)) {
-    return nullptr;
-  }
-
-  return tp;
-}
-
-}  // namespace
-
-#pragma GCC diagnostic pop
-}  // namespace mx
diff --git a/bindings/Python/Generated/IR/ValueKind.cpp b/bindings/Python/Generated/IR/ValueKind.cpp
deleted file mode 100644
index a7e1f15b6..000000000
--- a/bindings/Python/Generated/IR/ValueKind.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Value.h>
-#include <multiplier/Iterator.h>
-
-#include "Binding.h"
-#include "Error.h"
-#include "Types.h"
-
-namespace mx {
-namespace {
-using T = mx::ir::ValueKind;
-}  // namespace
-
-namespace {
-static PyTypeObject *gType = nullptr;
-}  // namespace
-
-template <>
-PyTypeObject *PythonBinding<T>::type(void) noexcept {
-  return gType;
-}
-
-template <>
-SharedPyObject *PythonBinding<T>::to_python(T val) noexcept {
-  return PyObject_GetAttrString(reinterpret_cast<BorrowedPyObject *>(gType),
-                                EnumeratorName(val));
-}
-
-template <>
-std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
-  if (!obj) {
-    return std::nullopt;
-  }
-
-  if (Py_TYPE(obj) != gType) {
-    return std::nullopt;
-  }
-
-  SharedPyPtr long_val(PyObject_GetAttrString(obj, "value"));
-  if (!long_val) {
-    PyErr_Clear();
-    return std::nullopt;
-  }
-
-  if (!PyLong_Check(long_val.Get())) {
-    return std::nullopt;
-  }
-
-  int did_overflow = 0;
-  const auto ret = static_cast<T>(
-      PyLong_AsLongLongAndOverflow(long_val.Get(), &did_overflow));
-  if (did_overflow) {
-    return std::nullopt;
-  }
-
-  return ret;
-}
-
-template <>
-bool PythonBinding<T>::load(BorrowedPyObject *module) noexcept {
-  const char * const enum_name = EnumerationName(T{});
-  bool created = false;
-
-  if (!gType) {
-    SharedPyPtr enum_module(PyImport_ImportModule("enum"));
-    if (!enum_module) {
-      return false;
-    }
-
-    SharedPyPtr int_enum(PyObject_GetAttrString(enum_module.Get(), "IntEnum"));
-    if (!int_enum) {
-      return false;
-    }
-
-    SharedPyPtr enum_meta(PyObject_Type(int_enum.Get()));
-    SharedPyPtr prepare(PyObject_GetAttrString(enum_meta.Get(), "__prepare__"));
-    if (!prepare) {
-      return false;
-    }
-
-    // Get the `enum._EnumDict` for what we're making.
-    SharedPyPtr ns_dict(PyObject_CallFunction(prepare.Get(), "s(O)", enum_name, int_enum.Get()));
-    if (!ns_dict) {
-      return false;
-    }
-
-    // Assign each enumerator.
-    for (T val : EnumerationRange<T>()) {
-      auto ival = PyLong_FromUnsignedLongLong(static_cast<uint64_t>(val));
-      if (ival) {
-        auto iname = PyUnicode_FromString(EnumeratorName(val));
-        if (!PyObject_SetItem(ns_dict, iname, ival)) {
-          continue;
-        }
-
-        Py_DECREF(iname);
-        Py_DECREF(ival);
-      }
-      return false;
-    }
-
-    // Create the type.
-    auto enum_class = PyObject_CallFunction(
-        enum_meta.Get(), "s(O)O", enum_name, int_enum.Get(), ns_dict.Get());
-    if (!enum_class) {
-      return false;
-    }
-
-    if (!PyType_Check(enum_class)) {
-      Py_DECREF(enum_class);
-
-      PyErrorStreamer(PyExc_ImportError)
-          << "Created enum class for enumerator '" << enum_name
-          << "' is not a python type";
-      return false;
-    }
-
-    gType = reinterpret_cast<PyTypeObject *>(enum_class);
-    created = true;
-  }
-
-  auto tp_obj = reinterpret_cast<BorrowedPyObject *>(gType);
-  if (0 != PyModule_AddObjectRef(module, enum_name, tp_obj)) {
-    return false;
-  }
-
-  if (created) {
-    Py_DECREF(tp_obj);
-  }
-
-  return true;
-}
-
-}  // namespace mx
diff --git a/bindings/Python/Generated/Index.cpp b/bindings/Python/Generated/Index.cpp
index 8d2b900db..756944ed5 100644
--- a/bindings/Python/Generated/Index.cpp
+++ b/bindings/Python/Generated/Index.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -72,7 +71,7 @@ std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
   }
 
   PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1535]) || tp >= &(gTypes[1536])) {
+  if (tp < &(gTypes[867]) || tp >= &(gTypes[868])) {
     return std::nullopt;
   }
 
@@ -303,15 +302,7 @@ static PyMethodDef gMethods[] = {
             return ::mx::to_python(T::containing(arg_0.value()));
           }
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(T::containing(arg_0.value()));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<mx::ir::Operation>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -760,36 +751,6 @@ static PyMethodDef gMethods[] = {
     METH_FASTCALL,
     PyDoc_STR("Wrapper for mx::Index::compilation"),
   },
-  {
-    "operation",
-    reinterpret_cast<PyCFunction>(
-        +[] (BorrowedPyObject *self, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
-          T *obj = T_cast(self);
-          (void) args;
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<uint64_t>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(obj->operation(std::move(arg_0.value())));
-          }
-          while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<PackedOperationId>(args[0]);
-            if (!arg_0.has_value()) {
-              break;
-            }
-
-            return ::mx::to_python(obj->operation(std::move(arg_0.value())));
-          }
-
-          PyErrorStreamer(PyExc_TypeError)
-              << "Invalid arguments passed to 'operation'";
-          return nullptr;
-        }),
-    METH_FASTCALL,
-    PyDoc_STR("Wrapper for mx::Index::operation"),
-  },
   {
     "entity",
     reinterpret_cast<PyCFunction>(
@@ -841,7 +802,7 @@ static PyMethodDef gMethods[] = {
 namespace {
 
 PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1535]);
+  PyTypeObject * const tp = &(gTypes[867]);
   tp->tp_basicsize = sizeof(O);
   tp->tp_itemsize = 0;
   tp->tp_dealloc = [] (::PyObject *obj) {
diff --git a/bindings/Python/Generated/Reference.cpp b/bindings/Python/Generated/Reference.cpp
index b7ff5607e..38ee5d9de 100644
--- a/bindings/Python/Generated/Reference.cpp
+++ b/bindings/Python/Generated/Reference.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -311,16 +310,6 @@ static PyGetSetDef gProperties[] = {
     PyDoc_STR("Wrapper for mx::Reference::as_compilation"),
     nullptr,
   },
-  {
-    "as_operation",
-    reinterpret_cast<getter>(
-        +[] (BorrowedPyObject *self, void * /* closure */) -> SharedPyObject * {
-          return ::mx::to_python(T_cast(self)->as_operation());
-        }),
-    nullptr,
-    PyDoc_STR("Wrapper for mx::Reference::as_operation"),
-    nullptr,
-  },
   {}  // Sentinel.
 };
 }  // namespace
@@ -337,11 +326,11 @@ static PyMethodDef gMethods[] = {
             if (!arg_0.has_value()) {
               break;
             }
-            auto arg_1 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[1]);
+            auto arg_1 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[1]);
             if (!arg_1.has_value()) {
               break;
             }
-            auto arg_2 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[2]);
+            auto arg_2 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[2]);
             if (!arg_2.has_value()) {
               break;
             }
@@ -353,15 +342,15 @@ static PyMethodDef gMethods[] = {
             if (!arg_0.has_value()) {
               break;
             }
-            auto arg_1 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[1]);
+            auto arg_1 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[1]);
             if (!arg_1.has_value()) {
               break;
             }
-            auto arg_2 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[2]);
+            auto arg_2 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[2]);
             if (!arg_2.has_value()) {
               break;
             }
-            auto arg_3 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[3]);
+            auto arg_3 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[3]);
             if (!arg_3.has_value()) {
               break;
             }
@@ -382,7 +371,7 @@ static PyMethodDef gMethods[] = {
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
@@ -403,7 +392,7 @@ static PyMethodDef gMethods[] = {
         +[] (BorrowedPyObject *, BorrowedPyObject * const *args, int num_args) -> SharedPyObject * {
           (void) args;
           while (num_args == 1) {
-            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation, mx::ir::Operation>>(args[0]);
+            auto arg_0 = ::mx::from_python<std::variant<std::monostate, mx::Fragment, mx::Decl, mx::Stmt, mx::Attr, mx::Macro, mx::Type, mx::File, mx::Token, mx::TemplateArgument, mx::TemplateParameterList, mx::CXXBaseSpecifier, mx::Designator, mx::CXXCtorInitializer, mx::Compilation>>(args[0]);
             if (!arg_0.has_value()) {
               break;
             }
diff --git a/bindings/Python/Generated/ReferenceKind.cpp b/bindings/Python/Generated/ReferenceKind.cpp
index fdda5f571..b46f29eeb 100644
--- a/bindings/Python/Generated/ReferenceKind.cpp
+++ b/bindings/Python/Generated/ReferenceKind.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
diff --git a/bindings/Python/Generated/RegexQuery.cpp b/bindings/Python/Generated/RegexQuery.cpp
index 2e57d98a6..9476d7a32 100644
--- a/bindings/Python/Generated/RegexQuery.cpp
+++ b/bindings/Python/Generated/RegexQuery.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend.h>
 #include <multiplier/Index.h>
-#include <multiplier/IR.h>
 #include <multiplier/Re2.h>
 
 #include <cassert>
@@ -72,7 +71,7 @@ std::optional<T> PythonBinding<T>::from_python(BorrowedPyObject *obj) noexcept {
   }
 
   PyTypeObject * const tp = Py_TYPE(obj);
-  if (tp < &(gTypes[1536]) || tp >= &(gTypes[1537])) {
+  if (tp < &(gTypes[868]) || tp >= &(gTypes[869])) {
     return std::nullopt;
   }
 
@@ -195,7 +194,7 @@ static PyMethodDef gMethods[] = {
 namespace {
 
 PyTypeObject *InitType(void) noexcept {
-  PyTypeObject * const tp = &(gTypes[1536]);
+  PyTypeObject * const tp = &(gTypes[868]);
   tp->tp_basicsize = sizeof(O);
   tp->tp_itemsize = 0;
   tp->tp_dealloc = [] (::PyObject *obj) {
diff --git a/bindings/Python/Module.cpp b/bindings/Python/Module.cpp
index c200e67ac..2a4918417 100644
--- a/bindings/Python/Module.cpp
+++ b/bindings/Python/Module.cpp
@@ -48,37 +48,6 @@ static LoaderFunc * const gLoaders[] = {
   PythonBinding<mx::RegexQuery>::load,
 };
 
-// multiplier.ir
-static PyModuleDef gIRModule = {
-  .m_name = "ir",
-  .m_doc = PyDoc_STR("Wrapper of IR"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gIRLoaders[] = {
-  PythonBinding<mx::ir::AttributeKind>::load,
-  PythonBinding<mx::ir::Attribute>::load,
-  PythonBinding<mx::ir::ValueKind>::load,
-  PythonBinding<mx::ir::Value>::load,
-  PythonBinding<mx::ir::Block>::load,
-  PythonBinding<mx::ir::Argument>::load,
-  PythonBinding<mx::ir::Label>::load,
-  PythonBinding<mx::ir::OperationKind>::load,
-  PythonBinding<mx::ir::Operation>::load,
-  PythonBinding<mx::ir::Result>::load,
-  PythonBinding<mx::ir::Operand>::load,
-  PythonBinding<mx::ir::Symbol>::load,
-  PythonBinding<mx::ir::BasicBlockOrder>::load,
-  PythonBinding<mx::ir::Region>::load,
-  PythonBinding<mx::ir::TypeKind>::load,
-  PythonBinding<mx::ir::Type>::load,
-};
-
 // multiplier.ast
 static PyModuleDef gASTModule = {
   .m_name = "ast",
@@ -1483,399 +1452,6 @@ static LoaderFunc * const gASTLoaders[] = {
   PythonBinding<mx::EmptyDecl>::load,
 };
 
-// multiplier.ir.abi
-static PyModuleDef gABIModule = {
-  .m_name = "abi",
-  .m_doc = PyDoc_STR("Wrapper of IR/ABI"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gABILoaders[] = {
-  PythonBinding<mx::ir::abi::Operation>::load,
-  PythonBinding<mx::ir::abi::CallArgsOp>::load,
-  PythonBinding<mx::ir::abi::CallExecutionOp>::load,
-  PythonBinding<mx::ir::abi::CallOp>::load,
-  PythonBinding<mx::ir::abi::CallRetsOp>::load,
-  PythonBinding<mx::ir::abi::DirectOp>::load,
-  PythonBinding<mx::ir::abi::EpilogueOp>::load,
-  PythonBinding<mx::ir::abi::FuncOp>::load,
-  PythonBinding<mx::ir::abi::IndirectOp>::load,
-  PythonBinding<mx::ir::abi::PrologueOp>::load,
-  PythonBinding<mx::ir::abi::RetDirectOp>::load,
-  PythonBinding<mx::ir::abi::YieldOp>::load,
-};
-
-// multiplier.ir.llvm
-static PyModuleDef gLLVMModule = {
-  .m_name = "llvm",
-  .m_doc = PyDoc_STR("Wrapper of IR/LLVM"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gLLVMLoaders[] = {
-  PythonBinding<mx::ir::llvm::Attribute>::load,
-  PythonBinding<mx::ir::llvm::CConvAttr>::load,
-  PythonBinding<mx::ir::llvm::ComdatAttr>::load,
-  PythonBinding<mx::ir::llvm::LinkageAttr>::load,
-  PythonBinding<mx::ir::llvm::FramePointerKindAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopVectorizeAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopInterleaveAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopUnrollAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopUnrollAndJamAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopLICMAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopDistributeAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopPipelineAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopPeeledAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopUnswitchAttr>::load,
-  PythonBinding<mx::ir::llvm::LoopAnnotationAttr>::load,
-  PythonBinding<mx::ir::llvm::DIExpressionElemAttr>::load,
-  PythonBinding<mx::ir::llvm::DIExpressionAttr>::load,
-  PythonBinding<mx::ir::llvm::DINullTypeAttr>::load,
-  PythonBinding<mx::ir::llvm::DIBasicTypeAttr>::load,
-  PythonBinding<mx::ir::llvm::DICompileUnitAttr>::load,
-  PythonBinding<mx::ir::llvm::DICompositeTypeAttr>::load,
-  PythonBinding<mx::ir::llvm::DIDerivedTypeAttr>::load,
-  PythonBinding<mx::ir::llvm::DIFileAttr>::load,
-  PythonBinding<mx::ir::llvm::DIGlobalVariableExpressionAttr>::load,
-  PythonBinding<mx::ir::llvm::DIGlobalVariableAttr>::load,
-  PythonBinding<mx::ir::llvm::DILexicalBlockAttr>::load,
-  PythonBinding<mx::ir::llvm::DILexicalBlockFileAttr>::load,
-  PythonBinding<mx::ir::llvm::DILocalVariableAttr>::load,
-  PythonBinding<mx::ir::llvm::DISubprogramAttr>::load,
-  PythonBinding<mx::ir::llvm::DIModuleAttr>::load,
-  PythonBinding<mx::ir::llvm::DINamespaceAttr>::load,
-  PythonBinding<mx::ir::llvm::DISubrangeAttr>::load,
-  PythonBinding<mx::ir::llvm::DISubroutineTypeAttr>::load,
-  PythonBinding<mx::ir::llvm::DILabelAttr>::load,
-  PythonBinding<mx::ir::llvm::MemoryEffectsAttr>::load,
-  PythonBinding<mx::ir::llvm::AliasScopeDomainAttr>::load,
-  PythonBinding<mx::ir::llvm::AliasScopeAttr>::load,
-  PythonBinding<mx::ir::llvm::AccessGroupAttr>::load,
-  PythonBinding<mx::ir::llvm::TBAARootAttr>::load,
-  PythonBinding<mx::ir::llvm::TBAAMemberAttr>::load,
-  PythonBinding<mx::ir::llvm::TBAATypeDescriptorAttr>::load,
-  PythonBinding<mx::ir::llvm::TBAATagAttr>::load,
-  PythonBinding<mx::ir::llvm::VScaleRangeAttr>::load,
-  PythonBinding<mx::ir::llvm::TargetFeaturesAttr>::load,
-  PythonBinding<mx::ir::llvm::IntegerOverflowFlagsAttr>::load,
-  PythonBinding<mx::ir::llvm::FastmathFlagsAttr>::load,
-  PythonBinding<mx::ir::llvm::Type>::load,
-  PythonBinding<mx::ir::llvm::ArrayType>::load,
-  PythonBinding<mx::ir::llvm::FunctionType>::load,
-  PythonBinding<mx::ir::llvm::PointerType>::load,
-  PythonBinding<mx::ir::llvm::FixedVectorType>::load,
-  PythonBinding<mx::ir::llvm::ScalableVectorType>::load,
-  PythonBinding<mx::ir::llvm::TargetExtType>::load,
-  PythonBinding<mx::ir::llvm::Operation>::load,
-  PythonBinding<mx::ir::llvm::AShrOp>::load,
-  PythonBinding<mx::ir::llvm::AddOp>::load,
-  PythonBinding<mx::ir::llvm::AddrSpaceCastOp>::load,
-  PythonBinding<mx::ir::llvm::AddressOfOp>::load,
-  PythonBinding<mx::ir::llvm::AllocaOp>::load,
-  PythonBinding<mx::ir::llvm::AndOp>::load,
-  PythonBinding<mx::ir::llvm::AtomicCmpXchgOp>::load,
-  PythonBinding<mx::ir::llvm::AtomicRMWOp>::load,
-  PythonBinding<mx::ir::llvm::BitcastOp>::load,
-  PythonBinding<mx::ir::llvm::BrOp>::load,
-  PythonBinding<mx::ir::llvm::CallIntrinsicOp>::load,
-  PythonBinding<mx::ir::llvm::CallOp>::load,
-  PythonBinding<mx::ir::llvm::ComdatOp>::load,
-  PythonBinding<mx::ir::llvm::ComdatSelectorOp>::load,
-  PythonBinding<mx::ir::llvm::CondBrOp>::load,
-  PythonBinding<mx::ir::llvm::ConstantOp>::load,
-  PythonBinding<mx::ir::llvm::ExtractElementOp>::load,
-  PythonBinding<mx::ir::llvm::ExtractValueOp>::load,
-  PythonBinding<mx::ir::llvm::FAddOp>::load,
-  PythonBinding<mx::ir::llvm::FCmpOp>::load,
-  PythonBinding<mx::ir::llvm::FDivOp>::load,
-  PythonBinding<mx::ir::llvm::FMulOp>::load,
-  PythonBinding<mx::ir::llvm::FNegOp>::load,
-  PythonBinding<mx::ir::llvm::FPExtOp>::load,
-  PythonBinding<mx::ir::llvm::FPToSIOp>::load,
-  PythonBinding<mx::ir::llvm::FPToUIOp>::load,
-  PythonBinding<mx::ir::llvm::FPTruncOp>::load,
-  PythonBinding<mx::ir::llvm::FRemOp>::load,
-  PythonBinding<mx::ir::llvm::FSubOp>::load,
-  PythonBinding<mx::ir::llvm::FenceOp>::load,
-  PythonBinding<mx::ir::llvm::FreezeOp>::load,
-  PythonBinding<mx::ir::llvm::GetElementPtrOp>::load,
-  PythonBinding<mx::ir::llvm::GlobalCtorsOp>::load,
-  PythonBinding<mx::ir::llvm::GlobalDtorsOp>::load,
-  PythonBinding<mx::ir::llvm::GlobalOp>::load,
-  PythonBinding<mx::ir::llvm::ICmpOp>::load,
-  PythonBinding<mx::ir::llvm::InlineAsmOp>::load,
-  PythonBinding<mx::ir::llvm::InsertElementOp>::load,
-  PythonBinding<mx::ir::llvm::InsertValueOp>::load,
-  PythonBinding<mx::ir::llvm::IntToPtrOp>::load,
-  PythonBinding<mx::ir::llvm::InvokeOp>::load,
-  PythonBinding<mx::ir::llvm::FuncOp>::load,
-  PythonBinding<mx::ir::llvm::LShrOp>::load,
-  PythonBinding<mx::ir::llvm::LandingpadOp>::load,
-  PythonBinding<mx::ir::llvm::LinkerOptionsOp>::load,
-  PythonBinding<mx::ir::llvm::LoadOp>::load,
-  PythonBinding<mx::ir::llvm::MulOp>::load,
-  PythonBinding<mx::ir::llvm::NoneTokenOp>::load,
-  PythonBinding<mx::ir::llvm::OrOp>::load,
-  PythonBinding<mx::ir::llvm::PoisonOp>::load,
-  PythonBinding<mx::ir::llvm::PtrToIntOp>::load,
-  PythonBinding<mx::ir::llvm::ResumeOp>::load,
-  PythonBinding<mx::ir::llvm::ReturnOp>::load,
-  PythonBinding<mx::ir::llvm::SDivOp>::load,
-  PythonBinding<mx::ir::llvm::SExtOp>::load,
-  PythonBinding<mx::ir::llvm::SIToFPOp>::load,
-  PythonBinding<mx::ir::llvm::SRemOp>::load,
-  PythonBinding<mx::ir::llvm::SelectOp>::load,
-  PythonBinding<mx::ir::llvm::ShlOp>::load,
-  PythonBinding<mx::ir::llvm::ShuffleVectorOp>::load,
-  PythonBinding<mx::ir::llvm::StoreOp>::load,
-  PythonBinding<mx::ir::llvm::SubOp>::load,
-  PythonBinding<mx::ir::llvm::SwitchOp>::load,
-  PythonBinding<mx::ir::llvm::TruncOp>::load,
-  PythonBinding<mx::ir::llvm::UDivOp>::load,
-  PythonBinding<mx::ir::llvm::UIToFPOp>::load,
-  PythonBinding<mx::ir::llvm::URemOp>::load,
-  PythonBinding<mx::ir::llvm::UndefOp>::load,
-  PythonBinding<mx::ir::llvm::UnreachableOp>::load,
-  PythonBinding<mx::ir::llvm::XOrOp>::load,
-  PythonBinding<mx::ir::llvm::ZExtOp>::load,
-  PythonBinding<mx::ir::llvm::ZeroOp>::load,
-  PythonBinding<mx::ir::llvm::AbsOp>::load,
-  PythonBinding<mx::ir::llvm::AnnotationOp>::load,
-  PythonBinding<mx::ir::llvm::AssumeOp>::load,
-  PythonBinding<mx::ir::llvm::BitReverseOp>::load,
-  PythonBinding<mx::ir::llvm::ByteSwapOp>::load,
-  PythonBinding<mx::ir::llvm::CopySignOp>::load,
-  PythonBinding<mx::ir::llvm::CoroAlignOp>::load,
-  PythonBinding<mx::ir::llvm::CoroBeginOp>::load,
-  PythonBinding<mx::ir::llvm::CoroEndOp>::load,
-  PythonBinding<mx::ir::llvm::CoroFreeOp>::load,
-  PythonBinding<mx::ir::llvm::CoroIdOp>::load,
-  PythonBinding<mx::ir::llvm::CoroPromiseOp>::load,
-  PythonBinding<mx::ir::llvm::CoroResumeOp>::load,
-  PythonBinding<mx::ir::llvm::CoroSaveOp>::load,
-  PythonBinding<mx::ir::llvm::CoroSizeOp>::load,
-  PythonBinding<mx::ir::llvm::CoroSuspendOp>::load,
-  PythonBinding<mx::ir::llvm::CosOp>::load,
-  PythonBinding<mx::ir::llvm::CountLeadingZerosOp>::load,
-  PythonBinding<mx::ir::llvm::CountTrailingZerosOp>::load,
-  PythonBinding<mx::ir::llvm::CtPopOp>::load,
-  PythonBinding<mx::ir::llvm::DbgDeclareOp>::load,
-  PythonBinding<mx::ir::llvm::DbgLabelOp>::load,
-  PythonBinding<mx::ir::llvm::DbgValueOp>::load,
-  PythonBinding<mx::ir::llvm::DebugTrapOp>::load,
-  PythonBinding<mx::ir::llvm::EhTypeidForOp>::load,
-  PythonBinding<mx::ir::llvm::Exp2Op>::load,
-  PythonBinding<mx::ir::llvm::ExpOp>::load,
-  PythonBinding<mx::ir::llvm::ExpectOp>::load,
-  PythonBinding<mx::ir::llvm::ExpectWithProbabilityOp>::load,
-  PythonBinding<mx::ir::llvm::FAbsOp>::load,
-  PythonBinding<mx::ir::llvm::FCeilOp>::load,
-  PythonBinding<mx::ir::llvm::FFloorOp>::load,
-  PythonBinding<mx::ir::llvm::FMAOp>::load,
-  PythonBinding<mx::ir::llvm::FMulAddOp>::load,
-  PythonBinding<mx::ir::llvm::FTruncOp>::load,
-  PythonBinding<mx::ir::llvm::FShlOp>::load,
-  PythonBinding<mx::ir::llvm::FShrOp>::load,
-  PythonBinding<mx::ir::llvm::GetActiveLaneMaskOp>::load,
-  PythonBinding<mx::ir::llvm::InvariantEndOp>::load,
-  PythonBinding<mx::ir::llvm::InvariantStartOp>::load,
-  PythonBinding<mx::ir::llvm::IsConstantOp>::load,
-  PythonBinding<mx::ir::llvm::IsFPClassOp>::load,
-  PythonBinding<mx::ir::llvm::LifetimeEndOp>::load,
-  PythonBinding<mx::ir::llvm::LifetimeStartOp>::load,
-  PythonBinding<mx::ir::llvm::RoundAndCastToLongLongOp>::load,
-  PythonBinding<mx::ir::llvm::RoundAndCastToNearestLongLongOp>::load,
-  PythonBinding<mx::ir::llvm::Log10Op>::load,
-  PythonBinding<mx::ir::llvm::Log2Op>::load,
-  PythonBinding<mx::ir::llvm::LogOp>::load,
-  PythonBinding<mx::ir::llvm::RoundAndCastToLongOp>::load,
-  PythonBinding<mx::ir::llvm::RoundAndCastToNearestLongOp>::load,
-  PythonBinding<mx::ir::llvm::MaskedLoadOp>::load,
-  PythonBinding<mx::ir::llvm::MaskedStoreOp>::load,
-  PythonBinding<mx::ir::llvm::MatrixColumnMajorLoadOp>::load,
-  PythonBinding<mx::ir::llvm::MatrixColumnMajorStoreOp>::load,
-  PythonBinding<mx::ir::llvm::MatrixMultiplyOp>::load,
-  PythonBinding<mx::ir::llvm::MatrixTransposeOp>::load,
-  PythonBinding<mx::ir::llvm::MaxNumOp>::load,
-  PythonBinding<mx::ir::llvm::MaximumOp>::load,
-  PythonBinding<mx::ir::llvm::MemcpyInlineOp>::load,
-  PythonBinding<mx::ir::llvm::MemcpyOp>::load,
-  PythonBinding<mx::ir::llvm::MemmoveOp>::load,
-  PythonBinding<mx::ir::llvm::MemsetOp>::load,
-  PythonBinding<mx::ir::llvm::MinNumOp>::load,
-  PythonBinding<mx::ir::llvm::MinimumOp>::load,
-  PythonBinding<mx::ir::llvm::RoundToNearbyIntOp>::load,
-  PythonBinding<mx::ir::llvm::NoAliasScopeDeclOp>::load,
-  PythonBinding<mx::ir::llvm::PowIOp>::load,
-  PythonBinding<mx::ir::llvm::FPowOp>::load,
-  PythonBinding<mx::ir::llvm::PrefetchOp>::load,
-  PythonBinding<mx::ir::llvm::PtrAnnotationOp>::load,
-  PythonBinding<mx::ir::llvm::RoundToIntOp>::load,
-  PythonBinding<mx::ir::llvm::RoundToNearestEvenOp>::load,
-  PythonBinding<mx::ir::llvm::RoundToNearestOp>::load,
-  PythonBinding<mx::ir::llvm::SAddSatOp>::load,
-  PythonBinding<mx::ir::llvm::SAddWithOverflowOp>::load,
-  PythonBinding<mx::ir::llvm::SMaxOp>::load,
-  PythonBinding<mx::ir::llvm::SMinOp>::load,
-  PythonBinding<mx::ir::llvm::SMulWithOverflowOp>::load,
-  PythonBinding<mx::ir::llvm::SSACopyOp>::load,
-  PythonBinding<mx::ir::llvm::SShlSatOp>::load,
-  PythonBinding<mx::ir::llvm::SSubSatOp>::load,
-  PythonBinding<mx::ir::llvm::SSubWithOverflowOp>::load,
-  PythonBinding<mx::ir::llvm::SinOp>::load,
-  PythonBinding<mx::ir::llvm::SqrtOp>::load,
-  PythonBinding<mx::ir::llvm::StackRestoreOp>::load,
-  PythonBinding<mx::ir::llvm::StackSaveOp>::load,
-  PythonBinding<mx::ir::llvm::StepVectorOp>::load,
-  PythonBinding<mx::ir::llvm::ThreadLocalAddressOp>::load,
-  PythonBinding<mx::ir::llvm::TrapOp>::load,
-  PythonBinding<mx::ir::llvm::UAddSatOp>::load,
-  PythonBinding<mx::ir::llvm::UAddWithOverflowOp>::load,
-  PythonBinding<mx::ir::llvm::UBSanTrapOp>::load,
-  PythonBinding<mx::ir::llvm::UMaxOp>::load,
-  PythonBinding<mx::ir::llvm::UMinOp>::load,
-  PythonBinding<mx::ir::llvm::UMulWithOverflowOp>::load,
-  PythonBinding<mx::ir::llvm::UShlSatOp>::load,
-  PythonBinding<mx::ir::llvm::USubSatOp>::load,
-  PythonBinding<mx::ir::llvm::USubWithOverflowOp>::load,
-  PythonBinding<mx::ir::llvm::VPAShrOp>::load,
-  PythonBinding<mx::ir::llvm::VPAddOp>::load,
-  PythonBinding<mx::ir::llvm::VPAndOp>::load,
-  PythonBinding<mx::ir::llvm::VPFAddOp>::load,
-  PythonBinding<mx::ir::llvm::VPFDivOp>::load,
-  PythonBinding<mx::ir::llvm::VPFMulAddOp>::load,
-  PythonBinding<mx::ir::llvm::VPFMulOp>::load,
-  PythonBinding<mx::ir::llvm::VPFNegOp>::load,
-  PythonBinding<mx::ir::llvm::VPFPExtOp>::load,
-  PythonBinding<mx::ir::llvm::VPFPToSIOp>::load,
-  PythonBinding<mx::ir::llvm::VPFPToUIOp>::load,
-  PythonBinding<mx::ir::llvm::VPFPTruncOp>::load,
-  PythonBinding<mx::ir::llvm::VPFRemOp>::load,
-  PythonBinding<mx::ir::llvm::VPFSubOp>::load,
-  PythonBinding<mx::ir::llvm::VPFmaOp>::load,
-  PythonBinding<mx::ir::llvm::VPIntToPtrOp>::load,
-  PythonBinding<mx::ir::llvm::VPLShrOp>::load,
-  PythonBinding<mx::ir::llvm::VPLoadOp>::load,
-  PythonBinding<mx::ir::llvm::VPMergeMinOp>::load,
-  PythonBinding<mx::ir::llvm::VPMulOp>::load,
-  PythonBinding<mx::ir::llvm::VPOrOp>::load,
-  PythonBinding<mx::ir::llvm::VPPtrToIntOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceAddOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceAndOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceFAddOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceFMaxOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceFMinOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceFMulOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceMulOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceOrOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceSMaxOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceSMinOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceUMaxOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceUMinOp>::load,
-  PythonBinding<mx::ir::llvm::VPReduceXorOp>::load,
-  PythonBinding<mx::ir::llvm::VPSDivOp>::load,
-  PythonBinding<mx::ir::llvm::VPSExtOp>::load,
-  PythonBinding<mx::ir::llvm::VPSIToFPOp>::load,
-  PythonBinding<mx::ir::llvm::VPSRemOp>::load,
-  PythonBinding<mx::ir::llvm::VPSelectMinOp>::load,
-  PythonBinding<mx::ir::llvm::VPShlOp>::load,
-  PythonBinding<mx::ir::llvm::VPStoreOp>::load,
-  PythonBinding<mx::ir::llvm::VPStridedLoadOp>::load,
-  PythonBinding<mx::ir::llvm::VPStridedStoreOp>::load,
-  PythonBinding<mx::ir::llvm::VPSubOp>::load,
-  PythonBinding<mx::ir::llvm::VPTruncOp>::load,
-  PythonBinding<mx::ir::llvm::VPUDivOp>::load,
-  PythonBinding<mx::ir::llvm::VPUIToFPOp>::load,
-  PythonBinding<mx::ir::llvm::VPURemOp>::load,
-  PythonBinding<mx::ir::llvm::VPXorOp>::load,
-  PythonBinding<mx::ir::llvm::VPZExtOp>::load,
-  PythonBinding<mx::ir::llvm::VaCopyOp>::load,
-  PythonBinding<mx::ir::llvm::VaEndOp>::load,
-  PythonBinding<mx::ir::llvm::VaStartOp>::load,
-  PythonBinding<mx::ir::llvm::VarAnnotationOp>::load,
-  PythonBinding<mx::ir::llvm::MaskedCompressStoreOp>::load,
-  PythonBinding<mx::ir::llvm::MaskedExpandLoadOp>::load,
-  PythonBinding<mx::ir::llvm::MaskedGatherOp>::load,
-  PythonBinding<mx::ir::llvm::MaskedScatterOp>::load,
-  PythonBinding<mx::ir::llvm::VectorExtractOp>::load,
-  PythonBinding<mx::ir::llvm::VectorInsertOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceAddOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceAndOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceFAddOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceFMaxOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceFMaximumOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceFMinOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceFMinimumOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceFMulOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceMulOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceOrOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceSMaxOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceSMinOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceUMaxOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceUMinOp>::load,
-  PythonBinding<mx::ir::llvm::VectorReduceXorOp>::load,
-  PythonBinding<mx::ir::llvm::VScaleOp>::load,
-};
-
-// multiplier.ir.core
-static PyModuleDef gCoreModule = {
-  .m_name = "core",
-  .m_doc = PyDoc_STR("Wrapper of IR/Core"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gCoreLoaders[] = {
-  PythonBinding<mx::ir::core::Attribute>::load,
-  PythonBinding<mx::ir::core::BooleanAttr>::load,
-  PythonBinding<mx::ir::core::IntegerAttr>::load,
-  PythonBinding<mx::ir::core::FloatAttr>::load,
-  PythonBinding<mx::ir::core::VoidAttr>::load,
-  PythonBinding<mx::ir::core::SourceLanguageAttr>::load,
-  PythonBinding<mx::ir::core::GlobalLinkageKindAttr>::load,
-  PythonBinding<mx::ir::core::Type>::load,
-  PythonBinding<mx::ir::core::FunctionType>::load,
-  PythonBinding<mx::ir::core::Operation>::load,
-  PythonBinding<mx::ir::core::BinLAndOp>::load,
-  PythonBinding<mx::ir::core::BinLOrOp>::load,
-  PythonBinding<mx::ir::core::ImplicitReturnOp>::load,
-  PythonBinding<mx::ir::core::LazyOp>::load,
-  PythonBinding<mx::ir::core::ModuleOp>::load,
-  PythonBinding<mx::ir::core::ScopeOp>::load,
-  PythonBinding<mx::ir::core::SelectOp>::load,
-};
-
-// multiplier.ir.meta
-static PyModuleDef gMetaModule = {
-  .m_name = "meta",
-  .m_doc = PyDoc_STR("Wrapper of IR/Meta"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gMetaLoaders[] = {
-  PythonBinding<mx::ir::meta::Attribute>::load,
-  PythonBinding<mx::ir::meta::IdentifierAttr>::load,
-};
-
 // multiplier.frontend
 static PyModuleDef gFrontendModule = {
   .m_name = "frontend",
@@ -1942,405 +1518,6 @@ static LoaderFunc * const gFrontendLoaders[] = {
   PythonBinding<mx::IncludeMacroDirective>::load,
 };
 
-// multiplier.ir.memref
-static PyModuleDef gMemRefModule = {
-  .m_name = "memref",
-  .m_doc = PyDoc_STR("Wrapper of IR/MemRef"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gMemRefLoaders[] = {
-  PythonBinding<mx::ir::memref::Operation>::load,
-  PythonBinding<mx::ir::memref::AssumeAlignmentOp>::load,
-  PythonBinding<mx::ir::memref::AtomicRMWOp>::load,
-  PythonBinding<mx::ir::memref::AtomicYieldOp>::load,
-  PythonBinding<mx::ir::memref::CopyOp>::load,
-  PythonBinding<mx::ir::memref::GenericAtomicRMWOp>::load,
-  PythonBinding<mx::ir::memref::LoadOp>::load,
-  PythonBinding<mx::ir::memref::AllocOp>::load,
-  PythonBinding<mx::ir::memref::AllocaOp>::load,
-  PythonBinding<mx::ir::memref::AllocaScopeOp>::load,
-  PythonBinding<mx::ir::memref::AllocaScopeReturnOp>::load,
-  PythonBinding<mx::ir::memref::CastOp>::load,
-  PythonBinding<mx::ir::memref::CollapseShapeOp>::load,
-  PythonBinding<mx::ir::memref::DeallocOp>::load,
-  PythonBinding<mx::ir::memref::DimOp>::load,
-  PythonBinding<mx::ir::memref::DMAStartOp>::load,
-  PythonBinding<mx::ir::memref::DMAWaitOp>::load,
-  PythonBinding<mx::ir::memref::ExpandShapeOp>::load,
-  PythonBinding<mx::ir::memref::ExtractAlignedPointerAsIndexOp>::load,
-  PythonBinding<mx::ir::memref::ExtractStridedMetadataOp>::load,
-  PythonBinding<mx::ir::memref::GetGlobalOp>::load,
-  PythonBinding<mx::ir::memref::GlobalOp>::load,
-  PythonBinding<mx::ir::memref::MemorySpaceCastOp>::load,
-  PythonBinding<mx::ir::memref::PrefetchOp>::load,
-  PythonBinding<mx::ir::memref::RankOp>::load,
-  PythonBinding<mx::ir::memref::ReallocOp>::load,
-  PythonBinding<mx::ir::memref::ReinterpretCastOp>::load,
-  PythonBinding<mx::ir::memref::ReshapeOp>::load,
-  PythonBinding<mx::ir::memref::StoreOp>::load,
-  PythonBinding<mx::ir::memref::TransposeOp>::load,
-  PythonBinding<mx::ir::memref::ViewOp>::load,
-  PythonBinding<mx::ir::memref::SubViewOp>::load,
-};
-
-// multiplier.ir.builtin
-static PyModuleDef gBuiltinModule = {
-  .m_name = "builtin",
-  .m_doc = PyDoc_STR("Wrapper of IR/Builtin"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gBuiltinLoaders[] = {
-  PythonBinding<mx::ir::builtin::Attribute>::load,
-  PythonBinding<mx::ir::builtin::TypedAttr>::load,
-  PythonBinding<mx::ir::builtin::ElementsAttr>::load,
-  PythonBinding<mx::ir::builtin::AffineMapAttr>::load,
-  PythonBinding<mx::ir::builtin::ArrayAttr>::load,
-  PythonBinding<mx::ir::builtin::DenseArrayAttr>::load,
-  PythonBinding<mx::ir::builtin::DenseIntOrFPElementsAttr>::load,
-  PythonBinding<mx::ir::builtin::DenseStringElementsAttr>::load,
-  PythonBinding<mx::ir::builtin::DenseResourceElementsAttr>::load,
-  PythonBinding<mx::ir::builtin::DictionaryAttr>::load,
-  PythonBinding<mx::ir::builtin::FloatAttr>::load,
-  PythonBinding<mx::ir::builtin::IntegerAttr>::load,
-  PythonBinding<mx::ir::builtin::IntegerSetAttr>::load,
-  PythonBinding<mx::ir::builtin::OpaqueAttr>::load,
-  PythonBinding<mx::ir::builtin::SparseElementsAttr>::load,
-  PythonBinding<mx::ir::builtin::StridedLayoutAttr>::load,
-  PythonBinding<mx::ir::builtin::StringAttr>::load,
-  PythonBinding<mx::ir::builtin::SymbolRefAttr>::load,
-  PythonBinding<mx::ir::builtin::TypeAttr>::load,
-  PythonBinding<mx::ir::builtin::UnitAttr>::load,
-  PythonBinding<mx::ir::builtin::BoolAttr>::load,
-  PythonBinding<mx::ir::builtin::FlatSymbolRefAttr>::load,
-  PythonBinding<mx::ir::builtin::DenseIntElementsAttr>::load,
-  PythonBinding<mx::ir::builtin::DataLayoutSpecAttr>::load,
-  PythonBinding<mx::ir::builtin::Type>::load,
-  PythonBinding<mx::ir::builtin::ShapedType>::load,
-  PythonBinding<mx::ir::builtin::FloatType>::load,
-  PythonBinding<mx::ir::builtin::ComplexType>::load,
-  PythonBinding<mx::ir::builtin::Float8E5M2Type>::load,
-  PythonBinding<mx::ir::builtin::Float8E4M3FNType>::load,
-  PythonBinding<mx::ir::builtin::Float8E5M2FNUZType>::load,
-  PythonBinding<mx::ir::builtin::Float8E4M3FNUZType>::load,
-  PythonBinding<mx::ir::builtin::Float8E4M3B11FNUZType>::load,
-  PythonBinding<mx::ir::builtin::BFloat16Type>::load,
-  PythonBinding<mx::ir::builtin::Float16Type>::load,
-  PythonBinding<mx::ir::builtin::FloatTF32Type>::load,
-  PythonBinding<mx::ir::builtin::Float32Type>::load,
-  PythonBinding<mx::ir::builtin::Float64Type>::load,
-  PythonBinding<mx::ir::builtin::Float80Type>::load,
-  PythonBinding<mx::ir::builtin::Float128Type>::load,
-  PythonBinding<mx::ir::builtin::FunctionType>::load,
-  PythonBinding<mx::ir::builtin::IndexType>::load,
-  PythonBinding<mx::ir::builtin::IntegerType>::load,
-  PythonBinding<mx::ir::builtin::MemRefType>::load,
-  PythonBinding<mx::ir::builtin::NoneType>::load,
-  PythonBinding<mx::ir::builtin::OpaqueType>::load,
-  PythonBinding<mx::ir::builtin::RankedTensorType>::load,
-  PythonBinding<mx::ir::builtin::TupleType>::load,
-  PythonBinding<mx::ir::builtin::UnrankedMemRefType>::load,
-  PythonBinding<mx::ir::builtin::UnrankedTensorType>::load,
-  PythonBinding<mx::ir::builtin::VectorType>::load,
-  PythonBinding<mx::ir::builtin::Operation>::load,
-  PythonBinding<mx::ir::builtin::ModuleOp>::load,
-  PythonBinding<mx::ir::builtin::UnrealizedConversionCastOp>::load,
-};
-
-// multiplier.ir.lowlevel
-static PyModuleDef gLowLevelModule = {
-  .m_name = "lowlevel",
-  .m_doc = PyDoc_STR("Wrapper of IR/LowLevel"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gLowLevelLoaders[] = {
-  PythonBinding<mx::ir::ll::Operation>::load,
-  PythonBinding<mx::ir::ll::AllocaOp>::load,
-  PythonBinding<mx::ir::ll::ArgAllocaOp>::load,
-  PythonBinding<mx::ir::ll::BrOp>::load,
-  PythonBinding<mx::ir::ll::ConcatOp>::load,
-  PythonBinding<mx::ir::ll::CondBrOp>::load,
-  PythonBinding<mx::ir::ll::CondScopeRetOp>::load,
-  PythonBinding<mx::ir::ll::ExtractOp>::load,
-  PythonBinding<mx::ir::ll::InitializeVarOp>::load,
-  PythonBinding<mx::ir::ll::InlineScopeOp>::load,
-  PythonBinding<mx::ir::ll::LoadOp>::load,
-  PythonBinding<mx::ir::ll::FuncOp>::load,
-  PythonBinding<mx::ir::ll::StructGEPOp>::load,
-  PythonBinding<mx::ir::ll::ReturnOp>::load,
-  PythonBinding<mx::ir::ll::ScopeOp>::load,
-  PythonBinding<mx::ir::ll::ScopeRecurseOp>::load,
-  PythonBinding<mx::ir::ll::ScopeRetOp>::load,
-  PythonBinding<mx::ir::ll::StoreOp>::load,
-  PythonBinding<mx::ir::ll::SubscriptOp>::load,
-  PythonBinding<mx::ir::ll::UninitializedVarOp>::load,
-};
-
-// multiplier.ir.highlevel
-static PyModuleDef gHighLevelModule = {
-  .m_name = "highlevel",
-  .m_doc = PyDoc_STR("Wrapper of IR/HighLevel"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gHighLevelLoaders[] = {
-  PythonBinding<mx::ir::hl::Attribute>::load,
-  PythonBinding<mx::ir::hl::AnnotationAttr>::load,
-  PythonBinding<mx::ir::hl::FormatAttr>::load,
-  PythonBinding<mx::ir::hl::SectionAttr>::load,
-  PythonBinding<mx::ir::hl::AliasAttr>::load,
-  PythonBinding<mx::ir::hl::ErrorAttr>::load,
-  PythonBinding<mx::ir::hl::CountedByAttr>::load,
-  PythonBinding<mx::ir::hl::CleanupAttr>::load,
-  PythonBinding<mx::ir::hl::AlignedAttr>::load,
-  PythonBinding<mx::ir::hl::AlwaysInlineAttr>::load,
-  PythonBinding<mx::ir::hl::NoInlineAttr>::load,
-  PythonBinding<mx::ir::hl::ConstAttr>::load,
-  PythonBinding<mx::ir::hl::LoaderUninitializedAttr>::load,
-  PythonBinding<mx::ir::hl::NoInstrumentFunctionAttr>::load,
-  PythonBinding<mx::ir::hl::PackedAttr>::load,
-  PythonBinding<mx::ir::hl::PureAttr>::load,
-  PythonBinding<mx::ir::hl::WarnUnusedResultAttr>::load,
-  PythonBinding<mx::ir::hl::RestrictAttr>::load,
-  PythonBinding<mx::ir::hl::NoThrowAttr>::load,
-  PythonBinding<mx::ir::hl::NonNullAttr>::load,
-  PythonBinding<mx::ir::hl::LeafAttr>::load,
-  PythonBinding<mx::ir::hl::ColdAttr>::load,
-  PythonBinding<mx::ir::hl::TransparentUnionAttr>::load,
-  PythonBinding<mx::ir::hl::ReturnsTwiceAttr>::load,
-  PythonBinding<mx::ir::hl::MayAliasAttr>::load,
-  PythonBinding<mx::ir::hl::UnusedAttr>::load,
-  PythonBinding<mx::ir::hl::UsedAttr>::load,
-  PythonBinding<mx::ir::hl::GNUInlineAttr>::load,
-  PythonBinding<mx::ir::hl::NoCfCheckAttr>::load,
-  PythonBinding<mx::ir::hl::AvailableOnlyInDefaultEvalMethodAttr>::load,
-  PythonBinding<mx::ir::hl::AvailabilityAttrAttr>::load,
-  PythonBinding<mx::ir::hl::FallthroughAttr>::load,
-  PythonBinding<mx::ir::hl::NoProfileInstrumentFunctionAttr>::load,
-  PythonBinding<mx::ir::hl::AsmLabelAttr>::load,
-  PythonBinding<mx::ir::hl::ModeAttr>::load,
-  PythonBinding<mx::ir::hl::BuiltinAttr>::load,
-  PythonBinding<mx::ir::hl::AllocAlignAttr>::load,
-  PythonBinding<mx::ir::hl::AllocSizeAttr>::load,
-  PythonBinding<mx::ir::hl::DeprecatedAttr>::load,
-  PythonBinding<mx::ir::hl::MaxFieldAlignmentAttr>::load,
-  PythonBinding<mx::ir::hl::VisibilityAttr>::load,
-  PythonBinding<mx::ir::hl::AssumeAlignedAttr>::load,
-  PythonBinding<mx::ir::hl::CVQualifiersAttr>::load,
-  PythonBinding<mx::ir::hl::UCVQualifiersAttr>::load,
-  PythonBinding<mx::ir::hl::CVRQualifiersAttr>::load,
-  PythonBinding<mx::ir::hl::OffsetOfNodeAttr>::load,
-  PythonBinding<mx::ir::hl::Type>::load,
-  PythonBinding<mx::ir::hl::RecordType>::load,
-  PythonBinding<mx::ir::hl::EnumType>::load,
-  PythonBinding<mx::ir::hl::TypedefType>::load,
-  PythonBinding<mx::ir::hl::ElaboratedType>::load,
-  PythonBinding<mx::ir::hl::LabelType>::load,
-  PythonBinding<mx::ir::hl::ParenType>::load,
-  PythonBinding<mx::ir::hl::LValueType>::load,
-  PythonBinding<mx::ir::hl::RValueType>::load,
-  PythonBinding<mx::ir::hl::VoidType>::load,
-  PythonBinding<mx::ir::hl::BoolType>::load,
-  PythonBinding<mx::ir::hl::CharType>::load,
-  PythonBinding<mx::ir::hl::ShortType>::load,
-  PythonBinding<mx::ir::hl::IntType>::load,
-  PythonBinding<mx::ir::hl::LongType>::load,
-  PythonBinding<mx::ir::hl::LongLongType>::load,
-  PythonBinding<mx::ir::hl::Int128Type>::load,
-  PythonBinding<mx::ir::hl::HalfType>::load,
-  PythonBinding<mx::ir::hl::BFloat16Type>::load,
-  PythonBinding<mx::ir::hl::FloatType>::load,
-  PythonBinding<mx::ir::hl::DoubleType>::load,
-  PythonBinding<mx::ir::hl::LongDoubleType>::load,
-  PythonBinding<mx::ir::hl::Float128Type>::load,
-  PythonBinding<mx::ir::hl::ComplexType>::load,
-  PythonBinding<mx::ir::hl::PointerType>::load,
-  PythonBinding<mx::ir::hl::ArrayType>::load,
-  PythonBinding<mx::ir::hl::VectorType>::load,
-  PythonBinding<mx::ir::hl::DecayedType>::load,
-  PythonBinding<mx::ir::hl::AttributedType>::load,
-  PythonBinding<mx::ir::hl::AdjustedType>::load,
-  PythonBinding<mx::ir::hl::ReferenceType>::load,
-  PythonBinding<mx::ir::hl::TypeOfExprType>::load,
-  PythonBinding<mx::ir::hl::TypeOfTypeType>::load,
-  PythonBinding<mx::ir::hl::AutoType>::load,
-  PythonBinding<mx::ir::hl::AtomicType>::load,
-  PythonBinding<mx::ir::hl::Operation>::load,
-  PythonBinding<mx::ir::hl::RefOp>::load,
-  PythonBinding<mx::ir::hl::AccessSpecifierOp>::load,
-  PythonBinding<mx::ir::hl::AddFAssignOp>::load,
-  PythonBinding<mx::ir::hl::AddFOp>::load,
-  PythonBinding<mx::ir::hl::AddIAssignOp>::load,
-  PythonBinding<mx::ir::hl::AddIOp>::load,
-  PythonBinding<mx::ir::hl::AddrLabelExprOp>::load,
-  PythonBinding<mx::ir::hl::AddressOfOp>::load,
-  PythonBinding<mx::ir::hl::AlignOfExprOp>::load,
-  PythonBinding<mx::ir::hl::AlignOfTypeOp>::load,
-  PythonBinding<mx::ir::hl::AsmOp>::load,
-  PythonBinding<mx::ir::hl::AssignOp>::load,
-  PythonBinding<mx::ir::hl::AttributedStmtOp>::load,
-  PythonBinding<mx::ir::hl::BinAShrAssignOp>::load,
-  PythonBinding<mx::ir::hl::BinAShrOp>::load,
-  PythonBinding<mx::ir::hl::BinAndAssignOp>::load,
-  PythonBinding<mx::ir::hl::BinAndOp>::load,
-  PythonBinding<mx::ir::hl::BinCommaOp>::load,
-  PythonBinding<mx::ir::hl::BinLAndOp>::load,
-  PythonBinding<mx::ir::hl::BinLOrOp>::load,
-  PythonBinding<mx::ir::hl::BinLShrAssignOp>::load,
-  PythonBinding<mx::ir::hl::BinLShrOp>::load,
-  PythonBinding<mx::ir::hl::BinOrAssignOp>::load,
-  PythonBinding<mx::ir::hl::BinOrOp>::load,
-  PythonBinding<mx::ir::hl::BinShlAssignOp>::load,
-  PythonBinding<mx::ir::hl::BinShlOp>::load,
-  PythonBinding<mx::ir::hl::BinXorAssignOp>::load,
-  PythonBinding<mx::ir::hl::BinXorOp>::load,
-  PythonBinding<mx::ir::hl::BinaryCondOp>::load,
-  PythonBinding<mx::ir::hl::BreakOp>::load,
-  PythonBinding<mx::ir::hl::BuiltinBitCastOp>::load,
-  PythonBinding<mx::ir::hl::BuiltinTypesCompatiblePOp>::load,
-  PythonBinding<mx::ir::hl::CStyleCastOp>::load,
-  PythonBinding<mx::ir::hl::CallOp>::load,
-  PythonBinding<mx::ir::hl::CaseOp>::load,
-  PythonBinding<mx::ir::hl::ChooseExprOp>::load,
-  PythonBinding<mx::ir::hl::ClassDeclOp>::load,
-  PythonBinding<mx::ir::hl::CmpOp>::load,
-  PythonBinding<mx::ir::hl::CompoundLiteralOp>::load,
-  PythonBinding<mx::ir::hl::CondOp>::load,
-  PythonBinding<mx::ir::hl::CondYieldOp>::load,
-  PythonBinding<mx::ir::hl::ConstantOp>::load,
-  PythonBinding<mx::ir::hl::ContinueOp>::load,
-  PythonBinding<mx::ir::hl::CxxBaseSpecifierOp>::load,
-  PythonBinding<mx::ir::hl::CxxStructDeclOp>::load,
-  PythonBinding<mx::ir::hl::DeclRefOp>::load,
-  PythonBinding<mx::ir::hl::DefaultOp>::load,
-  PythonBinding<mx::ir::hl::DerefOp>::load,
-  PythonBinding<mx::ir::hl::DivFAssignOp>::load,
-  PythonBinding<mx::ir::hl::DivFOp>::load,
-  PythonBinding<mx::ir::hl::DivSAssignOp>::load,
-  PythonBinding<mx::ir::hl::DivSOp>::load,
-  PythonBinding<mx::ir::hl::DivUAssignOp>::load,
-  PythonBinding<mx::ir::hl::DivUOp>::load,
-  PythonBinding<mx::ir::hl::DoOp>::load,
-  PythonBinding<mx::ir::hl::EmptyDeclOp>::load,
-  PythonBinding<mx::ir::hl::EnumConstantOp>::load,
-  PythonBinding<mx::ir::hl::EnumDeclOp>::load,
-  PythonBinding<mx::ir::hl::EnumRefOp>::load,
-  PythonBinding<mx::ir::hl::ExprOp>::load,
-  PythonBinding<mx::ir::hl::ExtensionOp>::load,
-  PythonBinding<mx::ir::hl::FCmpOp>::load,
-  PythonBinding<mx::ir::hl::FieldDeclOp>::load,
-  PythonBinding<mx::ir::hl::FileScopeAsmOp>::load,
-  PythonBinding<mx::ir::hl::ForOp>::load,
-  PythonBinding<mx::ir::hl::FuncOp>::load,
-  PythonBinding<mx::ir::hl::FuncRefOp>::load,
-  PythonBinding<mx::ir::hl::GenericAssocExprOp>::load,
-  PythonBinding<mx::ir::hl::GenericSelectionExprOp>::load,
-  PythonBinding<mx::ir::hl::GlobalRefOp>::load,
-  PythonBinding<mx::ir::hl::GotoStmtOp>::load,
-  PythonBinding<mx::ir::hl::IfOp>::load,
-  PythonBinding<mx::ir::hl::ImagOp>::load,
-  PythonBinding<mx::ir::hl::ImplicitCastOp>::load,
-  PythonBinding<mx::ir::hl::IndirectCallOp>::load,
-  PythonBinding<mx::ir::hl::IndirectGotoStmtOp>::load,
-  PythonBinding<mx::ir::hl::InitListExprOp>::load,
-  PythonBinding<mx::ir::hl::InitializedConstantOp>::load,
-  PythonBinding<mx::ir::hl::LNotOp>::load,
-  PythonBinding<mx::ir::hl::LabelDeclOp>::load,
-  PythonBinding<mx::ir::hl::LabelStmtOp>::load,
-  PythonBinding<mx::ir::hl::MinusOp>::load,
-  PythonBinding<mx::ir::hl::MulFAssignOp>::load,
-  PythonBinding<mx::ir::hl::MulFOp>::load,
-  PythonBinding<mx::ir::hl::MulIAssignOp>::load,
-  PythonBinding<mx::ir::hl::MulIOp>::load,
-  PythonBinding<mx::ir::hl::NotOp>::load,
-  PythonBinding<mx::ir::hl::NullStmtOp>::load,
-  PythonBinding<mx::ir::hl::OffsetOfExprOp>::load,
-  PythonBinding<mx::ir::hl::OpaqueValueExprOp>::load,
-  PythonBinding<mx::ir::hl::PlusOp>::load,
-  PythonBinding<mx::ir::hl::PostDecOp>::load,
-  PythonBinding<mx::ir::hl::PostIncOp>::load,
-  PythonBinding<mx::ir::hl::PreDecOp>::load,
-  PythonBinding<mx::ir::hl::PreIncOp>::load,
-  PythonBinding<mx::ir::hl::PredefinedExprOp>::load,
-  PythonBinding<mx::ir::hl::PreferredAlignOfExprOp>::load,
-  PythonBinding<mx::ir::hl::PreferredAlignOfTypeOp>::load,
-  PythonBinding<mx::ir::hl::RealOp>::load,
-  PythonBinding<mx::ir::hl::RecordMemberOp>::load,
-  PythonBinding<mx::ir::hl::RemFAssignOp>::load,
-  PythonBinding<mx::ir::hl::RemFOp>::load,
-  PythonBinding<mx::ir::hl::RemSAssignOp>::load,
-  PythonBinding<mx::ir::hl::RemSOp>::load,
-  PythonBinding<mx::ir::hl::RemUAssignOp>::load,
-  PythonBinding<mx::ir::hl::RemUOp>::load,
-  PythonBinding<mx::ir::hl::ReturnOp>::load,
-  PythonBinding<mx::ir::hl::SizeOfExprOp>::load,
-  PythonBinding<mx::ir::hl::SizeOfTypeOp>::load,
-  PythonBinding<mx::ir::hl::StaticAssertDeclOp>::load,
-  PythonBinding<mx::ir::hl::StmtExprOp>::load,
-  PythonBinding<mx::ir::hl::StructDeclOp>::load,
-  PythonBinding<mx::ir::hl::SubFAssignOp>::load,
-  PythonBinding<mx::ir::hl::SubFOp>::load,
-  PythonBinding<mx::ir::hl::SubIAssignOp>::load,
-  PythonBinding<mx::ir::hl::SubIOp>::load,
-  PythonBinding<mx::ir::hl::SubscriptOp>::load,
-  PythonBinding<mx::ir::hl::SwitchOp>::load,
-  PythonBinding<mx::ir::hl::ThisOp>::load,
-  PythonBinding<mx::ir::hl::TranslationUnitOp>::load,
-  PythonBinding<mx::ir::hl::TypeAliasOp>::load,
-  PythonBinding<mx::ir::hl::TypeDeclOp>::load,
-  PythonBinding<mx::ir::hl::TypeDefOp>::load,
-  PythonBinding<mx::ir::hl::TypeOfExprOp>::load,
-  PythonBinding<mx::ir::hl::TypeYieldOp>::load,
-  PythonBinding<mx::ir::hl::UnionDeclOp>::load,
-  PythonBinding<mx::ir::hl::UnreachableOp>::load,
-  PythonBinding<mx::ir::hl::VAArgExprOp>::load,
-  PythonBinding<mx::ir::hl::ValueYieldOp>::load,
-  PythonBinding<mx::ir::hl::VarDeclOp>::load,
-  PythonBinding<mx::ir::hl::WhileOp>::load,
-};
-
-// multiplier.ir.unsupported
-static PyModuleDef gUnsupportedModule = {
-  .m_name = "unsupported",
-  .m_doc = PyDoc_STR("Wrapper of IR/Unsupported"),
-  .m_size = 0,
-  .m_methods = gEmptyMethods,
-  .m_slots = {},
-  .m_traverse = {},
-  .m_clear = {},
-  .m_free = {},
-};
-
-static LoaderFunc * const gUnsupportedLoaders[] = {
-  PythonBinding<mx::ir::unsup::Type>::load,
-  PythonBinding<mx::ir::unsup::UnsupportedType>::load,
-  PythonBinding<mx::ir::unsup::Operation>::load,
-  PythonBinding<mx::ir::unsup::UnsupportedDeclOp>::load,
-  PythonBinding<mx::ir::unsup::UnsupportedStmtOp>::load,
-};
-
 }  // namespace
 }  // namespace mx
 
@@ -2373,26 +1550,6 @@ PyMODINIT_FUNC PyInit_multiplier(void) {
     }
   }
 
-  auto irm = PyModule_Create(&mx::gIRModule);
-  if (!irm) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gIRLoaders) {
-    if (!loader(irm)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (m) {
-    if (0 != PyModule_AddObjectRef(m, "ir", irm)) {
-      Py_DECREF(irm);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
   auto astm = PyModule_Create(&mx::gASTModule);
   if (!astm) {
     return nullptr;
@@ -2413,86 +1570,6 @@ PyMODINIT_FUNC PyInit_multiplier(void) {
     }
   }
 
-  auto abim = PyModule_Create(&mx::gABIModule);
-  if (!abim) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gABILoaders) {
-    if (!loader(abim)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (irm) {
-    if (0 != PyModule_AddObjectRef(irm, "abi", abim)) {
-      Py_DECREF(abim);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  auto llvmm = PyModule_Create(&mx::gLLVMModule);
-  if (!llvmm) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gLLVMLoaders) {
-    if (!loader(llvmm)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (irm) {
-    if (0 != PyModule_AddObjectRef(irm, "llvm", llvmm)) {
-      Py_DECREF(llvmm);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  auto corem = PyModule_Create(&mx::gCoreModule);
-  if (!corem) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gCoreLoaders) {
-    if (!loader(corem)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (irm) {
-    if (0 != PyModule_AddObjectRef(irm, "core", corem)) {
-      Py_DECREF(corem);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  auto metam = PyModule_Create(&mx::gMetaModule);
-  if (!metam) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gMetaLoaders) {
-    if (!loader(metam)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (irm) {
-    if (0 != PyModule_AddObjectRef(irm, "meta", metam)) {
-      Py_DECREF(metam);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
   auto frontendm = PyModule_Create(&mx::gFrontendModule);
   if (!frontendm) {
     return nullptr;
@@ -2513,106 +1590,6 @@ PyMODINIT_FUNC PyInit_multiplier(void) {
     }
   }
 
-  auto memrefm = PyModule_Create(&mx::gMemRefModule);
-  if (!memrefm) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gMemRefLoaders) {
-    if (!loader(memrefm)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (irm) {
-    if (0 != PyModule_AddObjectRef(irm, "memref", memrefm)) {
-      Py_DECREF(memrefm);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  auto builtinm = PyModule_Create(&mx::gBuiltinModule);
-  if (!builtinm) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gBuiltinLoaders) {
-    if (!loader(builtinm)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (irm) {
-    if (0 != PyModule_AddObjectRef(irm, "builtin", builtinm)) {
-      Py_DECREF(builtinm);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  auto lowlevelm = PyModule_Create(&mx::gLowLevelModule);
-  if (!lowlevelm) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gLowLevelLoaders) {
-    if (!loader(lowlevelm)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (irm) {
-    if (0 != PyModule_AddObjectRef(irm, "lowlevel", lowlevelm)) {
-      Py_DECREF(lowlevelm);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  auto highlevelm = PyModule_Create(&mx::gHighLevelModule);
-  if (!highlevelm) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gHighLevelLoaders) {
-    if (!loader(highlevelm)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (irm) {
-    if (0 != PyModule_AddObjectRef(irm, "highlevel", highlevelm)) {
-      Py_DECREF(highlevelm);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  auto unsupportedm = PyModule_Create(&mx::gUnsupportedModule);
-  if (!unsupportedm) {
-    return nullptr;
-  }
-
-  for (auto loader : mx::gUnsupportedLoaders) {
-    if (!loader(unsupportedm)) {
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
-  if (irm) {
-    if (0 != PyModule_AddObjectRef(irm, "unsupported", unsupportedm)) {
-      Py_DECREF(unsupportedm);
-      Py_DECREF(m);
-      return nullptr;
-    }
-  }
-
   // Doesn't have any methods, so no schema is made for it. We manually inject
   // this so that we can handle `Token::location`.
   if (!mx::PythonBinding<mx::FileLocationCache>::load(frontendm)) {
diff --git a/bindings/Python/Types.cpp b/bindings/Python/Types.cpp
index a7cbb0b99..d6e235fce 100644
--- a/bindings/Python/Types.cpp
+++ b/bindings/Python/Types.cpp
@@ -10,6 +10,6 @@
 namespace mx {
 
 // Size is defined in the auto-generated `Types.cpp` file.
-PyTypeObject gTypes[1537] = {};
+PyTypeObject gTypes[869] = {};
 
 }  // namespace mx
diff --git a/bindings/Python/multiplier-stubs/__init__.py b/bindings/Python/multiplier-stubs/__init__.py
index acfba0a6e..130375055 100644
--- a/bindings/Python/multiplier-stubs/__init__.py
+++ b/bindings/Python/multiplier-stubs/__init__.py
@@ -31,18 +31,8 @@ class Entity(object, ABC):
   id: int
 
 import multiplier
-import multiplier.ir
 import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
 import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
 
 class EntityCategory(IntEnum):
   NOT_AN_ENTITY = 0
@@ -60,7 +50,6 @@ class EntityCategory(IntEnum):
   DESIGNATOR = 12
   CXX_CTOR_INITIALIZER = 13
   COMPILATION = 14
-  OPERATION = 15
 
 class BuiltinReferenceKind(IntEnum):
   USES_VALUE = 0
@@ -121,24 +110,23 @@ class Reference(object):
   as_designator: Optional[multiplier.ast.Designator]
   as_cxx_ctor_initializer: Optional[multiplier.ast.CXXCtorInitializer]
   as_compilation: Optional[multiplier.frontend.Compilation]
-  as_operation: Optional[multiplier.ir.Operation]
 
   @overload
   @staticmethod
-  def add(kind: multiplier.ReferenceKind, from_: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation], to: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> bool:
+  def add(kind: multiplier.ReferenceKind, from_: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation], to: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> bool:
     ...
 
   @overload
   @staticmethod
-  def add(kind: multiplier.ReferenceKind, from_: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation], to: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation], context: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> bool:
+  def add(kind: multiplier.ReferenceKind, from_: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation], to: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation], context: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> bool:
     ...
 
   @staticmethod
-  def FROM(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Iterable[multiplier.Reference]:
+  def FROM(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Iterable[multiplier.Reference]:
     ...
 
   @staticmethod
-  def to(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Iterable[multiplier.Reference]:
+  def to(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Iterable[multiplier.Reference]:
     ...
 
 class Fragment(multiplier.Entity):
@@ -218,16 +206,11 @@ def containing(arg_0: multiplier.frontend.Macro) -> multiplier.Fragment:
 
   @overload
   @staticmethod
-  def containing(arg_0: multiplier.ir.Operation) -> Optional[multiplier.Fragment]:
-    ...
-
-  @overload
-  @staticmethod
-  def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.Fragment]:
+  def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.Fragment]:
     ...
 
   @staticmethod
-  def FROM(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.Fragment]:
+  def FROM(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.Fragment]:
     ...
 
   @staticmethod
@@ -322,12 +305,7 @@ def containing(entity: multiplier.frontend.Token) -> Optional[multiplier.Index]:
 
   @overload
   @staticmethod
-  def containing(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.Index]:
-    ...
-
-  @overload
-  @staticmethod
-  def containing(entity: multiplier.ir.Operation) -> multiplier.Index:
+  def containing(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.Index]:
     ...
 
   def status(self, block: bool) -> multiplier.IndexStatus:
@@ -440,14 +418,6 @@ def compilation(self, id: int) -> Optional[multiplier.frontend.Compilation]:
   def compilation(self, id: multiplier.CompilationId) -> Optional[multiplier.frontend.Compilation]:
     ...
 
-  @overload
-  def operation(self, id: int) -> Optional[multiplier.ir.Operation]:
-    ...
-
-  @overload
-  def operation(self, id: multiplier.OperationId) -> Optional[multiplier.ir.Operation]:
-    ...
-
   def entity(self, eid: int) -> multiplier.Entity:
     ...
 
diff --git a/bindings/Python/multiplier-stubs/ast/__init__.py b/bindings/Python/multiplier-stubs/ast/__init__.py
index 85bd42943..d95cc0860 100644
--- a/bindings/Python/multiplier-stubs/ast/__init__.py
+++ b/bindings/Python/multiplier-stubs/ast/__init__.py
@@ -12,18 +12,8 @@
 from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
 import pathlib
 import multiplier
-import multiplier.ir
 import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
 import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
 
 class DeclKind(IntEnum):
   ACCESS_SPEC = 0
@@ -5560,7 +5550,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXCtorInitializer]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXCtorInitializer]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXCtorInitializer]:
     ...
 
   @overload
@@ -5629,7 +5619,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Designator]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.Designator]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Designator]:
     ...
 
   @overload
@@ -5699,7 +5689,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXBaseSpecifier]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXBaseSpecifier]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXBaseSpecifier]:
     ...
 
   @overload
@@ -5767,7 +5757,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateParameterLi
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TemplateParameterList]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateParameterList]:
     ...
 
   @overload
@@ -5842,7 +5832,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateArgument]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TemplateArgument]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateArgument]:
     ...
 
   @overload
@@ -5926,7 +5916,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Attr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.Attr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Attr]:
     ...
 
   @overload
@@ -5988,7 +5978,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlignValueAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AlignValueAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlignValueAttr]:
     ...
 
   @overload
@@ -6051,7 +6041,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AliasAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AliasAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AliasAttr]:
     ...
 
   @overload
@@ -6112,7 +6102,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AbiTagAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AbiTagAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AbiTagAttr]:
     ...
 
   @overload
@@ -6169,7 +6159,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeAttr]:
     ...
 
   @overload
@@ -6230,7 +6220,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SPtrAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SPtrAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SPtrAttr]:
     ...
 
   @overload
@@ -6291,7 +6281,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Ptr64Attr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.Ptr64Attr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Ptr64Attr]:
     ...
 
   @overload
@@ -6352,7 +6342,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Ptr32Attr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.Ptr32Attr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Ptr32Attr]:
     ...
 
   @overload
@@ -6414,7 +6404,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLPrivateAddres
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLPrivateAddressSpaceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLPrivateAddressSpaceAttr]:
     ...
 
   @overload
@@ -6476,7 +6466,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLLocalAddressS
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLLocalAddressSpaceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLLocalAddressSpaceAttr]:
     ...
 
   @overload
@@ -6537,7 +6527,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLGlobalHostAdd
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLGlobalHostAddressSpaceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLGlobalHostAddressSpaceAttr]:
     ...
 
   @overload
@@ -6598,7 +6588,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLGlobalDeviceA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLGlobalDeviceAddressSpaceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLGlobalDeviceAddressSpaceAttr]:
     ...
 
   @overload
@@ -6660,7 +6650,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLGlobalAddress
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLGlobalAddressSpaceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLGlobalAddressSpaceAttr]:
     ...
 
   @overload
@@ -6722,7 +6712,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLGenericAddres
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLGenericAddressSpaceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLGenericAddressSpaceAttr]:
     ...
 
   @overload
@@ -6784,7 +6774,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLConstantAddre
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLConstantAddressSpaceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLConstantAddressSpaceAttr]:
     ...
 
   @overload
@@ -6845,7 +6835,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCKindOfAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCKindOfAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCKindOfAttr]:
     ...
 
   @overload
@@ -6906,7 +6896,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCInertUnsafeUnre
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCInertUnsafeUnretainedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCInertUnsafeUnretainedAttr]:
     ...
 
   @overload
@@ -6967,7 +6957,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCGCAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCGCAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCGCAttr]:
     ...
 
   @overload
@@ -7028,7 +7018,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoDerefAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoDerefAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoDerefAttr]:
     ...
 
   @overload
@@ -7096,7 +7086,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLParamModifierAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLParamModifierAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLParamModifierAttr]:
     ...
 
   @overload
@@ -7157,7 +7147,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLGroupSharedAddr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLGroupSharedAddressSpaceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLGroupSharedAddressSpaceAttr]:
     ...
 
   @overload
@@ -7218,7 +7208,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CmseNSCallAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CmseNSCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CmseNSCallAttr]:
     ...
 
   @overload
@@ -7281,7 +7271,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BTFTypeTagAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BTFTypeTagAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BTFTypeTagAttr]:
     ...
 
   @overload
@@ -7342,7 +7332,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmStreamingCompati
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmStreamingCompatibleAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmStreamingCompatibleAttr]:
     ...
 
   @overload
@@ -7403,7 +7393,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmStreamingAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmStreamingAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmStreamingAttr]:
     ...
 
   @overload
@@ -7464,7 +7454,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmPreservesAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmPreservesAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmPreservesAttr]:
     ...
 
   @overload
@@ -7525,7 +7515,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmOutAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmOutAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmOutAttr]:
     ...
 
   @overload
@@ -7586,7 +7576,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmMveStrictPolymor
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmMveStrictPolymorphismAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmMveStrictPolymorphismAttr]:
     ...
 
   @overload
@@ -7647,7 +7637,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmInOutAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmInOutAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmInOutAttr]:
     ...
 
   @overload
@@ -7708,7 +7698,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmInAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmInAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmInAttr]:
     ...
 
   @overload
@@ -7771,7 +7761,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnnotateTypeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AnnotateTypeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnnotateTypeAttr]:
     ...
 
   @overload
@@ -7832,7 +7822,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AddressSpaceAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AddressSpaceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AddressSpaceAttr]:
     ...
 
   @overload
@@ -7893,7 +7883,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WebAssemblyFuncrefA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WebAssemblyFuncrefAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WebAssemblyFuncrefAttr]:
     ...
 
   @overload
@@ -7954,7 +7944,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UPtrAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UPtrAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UPtrAttr]:
     ...
 
   @overload
@@ -8015,7 +8005,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeNullableResultA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeNullableResultAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeNullableResultAttr]:
     ...
 
   @overload
@@ -8076,7 +8066,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeNullableAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeNullableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeNullableAttr]:
     ...
 
   @overload
@@ -8137,7 +8127,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeNullUnspecified
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeNullUnspecifiedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeNullUnspecifiedAttr]:
     ...
 
   @overload
@@ -8198,7 +8188,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeNonNullAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeNonNullAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeNonNullAttr]:
     ...
 
   @overload
@@ -8259,7 +8249,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ThreadAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ThreadAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ThreadAttr]:
     ...
 
   @overload
@@ -8323,7 +8313,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftVersionedRemov
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftVersionedRemovalAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftVersionedRemovalAttr]:
     ...
 
   @overload
@@ -8386,7 +8376,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftVersionedAddit
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftVersionedAdditionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftVersionedAdditionAttr]:
     ...
 
   @overload
@@ -8447,7 +8437,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftObjCMembersAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftObjCMembersAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftObjCMembersAttr]:
     ...
 
   @overload
@@ -8504,7 +8494,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StmtAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.StmtAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StmtAttr]:
     ...
 
   @overload
@@ -8566,7 +8556,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLUnrollHintAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLUnrollHintAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLUnrollHintAttr]:
     ...
 
   @overload
@@ -8627,7 +8617,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MustTailAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MustTailAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MustTailAttr]:
     ...
 
   @overload
@@ -8688,7 +8678,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LikelyAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LikelyAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LikelyAttr]:
     ...
 
   @overload
@@ -8749,7 +8739,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FallThroughAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FallThroughAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FallThroughAttr]:
     ...
 
   @overload
@@ -8811,7 +8801,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CodeAlignAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CodeAlignAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CodeAlignAttr]:
     ...
 
   @overload
@@ -8872,7 +8862,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnlikelyAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnlikelyAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnlikelyAttr]:
     ...
 
   @overload
@@ -8933,7 +8923,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RenderScriptKernelA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RenderScriptKernelAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RenderScriptKernelAttr]:
     ...
 
   @overload
@@ -8994,7 +8984,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OverloadableAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OverloadableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OverloadableAttr]:
     ...
 
   @overload
@@ -9059,7 +9049,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLAccessAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLAccessAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLAccessAttr]:
     ...
 
   @overload
@@ -9120,7 +9110,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRuntimeVisibleA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCRuntimeVisibleAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRuntimeVisibleAttr]:
     ...
 
   @overload
@@ -9183,7 +9173,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRuntimeNameAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCRuntimeNameAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRuntimeNameAttr]:
     ...
 
   @overload
@@ -9244,7 +9234,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCNonRuntimeProto
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCNonRuntimeProtocolAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCNonRuntimeProtocolAttr]:
     ...
 
   @overload
@@ -9305,7 +9295,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCNonLazyClassAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCNonLazyClassAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCNonLazyClassAttr]:
     ...
 
   @overload
@@ -9366,7 +9356,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCDirectMembersAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCDirectMembersAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCDirectMembersAttr]:
     ...
 
   @overload
@@ -9427,7 +9417,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCDirectAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCDirectAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCDirectAttr]:
     ...
 
   @overload
@@ -9488,7 +9478,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCDesignatedIniti
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCDesignatedInitializerAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCDesignatedInitializerAttr]:
     ...
 
   @overload
@@ -9549,7 +9539,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCClassStubAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCClassStubAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCClassStubAttr]:
     ...
 
   @overload
@@ -9610,7 +9600,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBoxableAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCBoxableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBoxableAttr]:
     ...
 
   @overload
@@ -9672,7 +9662,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPReferencedVarAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPReferencedVarAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPReferencedVarAttr]:
     ...
 
   @overload
@@ -9735,7 +9725,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareSimdDeclA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDeclareSimdDeclAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareSimdDeclAttr]:
     ...
 
   @overload
@@ -9797,7 +9787,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCaptureKindAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPCaptureKindAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCaptureKindAttr]:
     ...
 
   @overload
@@ -9858,7 +9848,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoEscapeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoEscapeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoEscapeAttr]:
     ...
 
   @overload
@@ -9919,7 +9909,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoBuiltinAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoBuiltinAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoBuiltinAttr]:
     ...
 
   @overload
@@ -9980,7 +9970,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ModeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ModeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ModeAttr]:
     ...
 
   @overload
@@ -10045,7 +10035,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LoopHintAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LoopHintAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LoopHintAttr]:
     ...
 
   @overload
@@ -10106,7 +10096,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LoaderUninitialized
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LoaderUninitializedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LoaderUninitializedAttr]:
     ...
 
   @overload
@@ -10169,7 +10159,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InitSegAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.InitSegAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InitSegAttr]:
     ...
 
   @overload
@@ -10227,7 +10217,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InheritableAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.InheritableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InheritableAttr]:
     ...
 
   @overload
@@ -10290,7 +10280,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IBOutletCollectionA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IBOutletCollectionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IBOutletCollectionAttr]:
     ...
 
   @overload
@@ -10351,7 +10341,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IBOutletAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IBOutletAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IBOutletAttr]:
     ...
 
   @overload
@@ -10412,7 +10402,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IBActionAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IBActionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IBActionAttr]:
     ...
 
   @overload
@@ -10473,7 +10463,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HotAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HotAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HotAttr]:
     ...
 
   @overload
@@ -10535,7 +10525,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLShaderAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLShaderAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLShaderAttr]:
     ...
 
   @overload
@@ -10600,7 +10590,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLResourceBinding
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLResourceBindingAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLResourceBindingAttr]:
     ...
 
   @overload
@@ -10662,7 +10652,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLResourceAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLResourceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLResourceAttr]:
     ...
 
   @overload
@@ -10723,7 +10713,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLNumThreadsAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLNumThreadsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLNumThreadsAttr]:
     ...
 
   @overload
@@ -10780,7 +10770,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLAnnotationAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLAnnotationAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLAnnotationAttr]:
     ...
 
   @overload
@@ -10841,7 +10831,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLSV_GroupIndexAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLSV_GroupIndexAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLSV_GroupIndexAttr]:
     ...
 
   @overload
@@ -10902,7 +10892,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLSV_DispatchThre
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLSV_DispatchThreadIDAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLSV_DispatchThreadIDAttr]:
     ...
 
   @overload
@@ -10963,7 +10953,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HIPManagedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HIPManagedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HIPManagedAttr]:
     ...
 
   @overload
@@ -11024,7 +11014,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GuardedVarAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.GuardedVarAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GuardedVarAttr]:
     ...
 
   @overload
@@ -11086,7 +11076,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GuardedByAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.GuardedByAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GuardedByAttr]:
     ...
 
   @overload
@@ -11147,7 +11137,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GNUInlineAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.GNUInlineAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GNUInlineAttr]:
     ...
 
   @overload
@@ -11209,7 +11199,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionReturnThunk
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FunctionReturnThunksAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionReturnThunksAttr]:
     ...
 
   @overload
@@ -11270,7 +11260,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FormatAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FormatAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FormatAttr]:
     ...
 
   @overload
@@ -11331,7 +11321,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FormatArgAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FormatArgAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FormatArgAttr]:
     ...
 
   @overload
@@ -11392,7 +11382,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FlattenAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FlattenAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FlattenAttr]:
     ...
 
   @overload
@@ -11453,7 +11443,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FlagEnumAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FlagEnumAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FlagEnumAttr]:
     ...
 
   @overload
@@ -11516,7 +11506,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FinalAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FinalAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FinalAttr]:
     ...
 
   @overload
@@ -11577,7 +11567,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FastCallAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FastCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FastCallAttr]:
     ...
 
   @overload
@@ -11645,7 +11635,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExternalSourceSymbo
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExternalSourceSymbolAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExternalSourceSymbolAttr]:
     ...
 
   @overload
@@ -11707,7 +11697,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExclusiveTrylockFun
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExclusiveTrylockFunctionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExclusiveTrylockFunctionAttr]:
     ...
 
   @overload
@@ -11768,7 +11758,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExcludeFromExplicit
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExcludeFromExplicitInstantiationAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExcludeFromExplicitInstantiationAttr]:
     ...
 
   @overload
@@ -11834,7 +11824,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ErrorAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ErrorAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ErrorAttr]:
     ...
 
   @overload
@@ -11896,7 +11886,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumExtensibilityAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.EnumExtensibilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnumExtensibilityAttr]:
     ...
 
   @overload
@@ -11959,7 +11949,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnforceTCBLeafAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.EnforceTCBLeafAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnforceTCBLeafAttr]:
     ...
 
   @overload
@@ -12022,7 +12012,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnforceTCBAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.EnforceTCBAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnforceTCBAttr]:
     ...
 
   @overload
@@ -12086,7 +12076,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnableIfAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.EnableIfAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnableIfAttr]:
     ...
 
   @overload
@@ -12147,7 +12137,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EmptyBasesAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.EmptyBasesAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EmptyBasesAttr]:
     ...
 
   @overload
@@ -12208,7 +12198,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DisableTailCallsAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DisableTailCallsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DisableTailCallsAttr]:
     ...
 
   @overload
@@ -12269,7 +12259,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DisableSanitizerIns
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DisableSanitizerInstrumentationAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DisableSanitizerInstrumentationAttr]:
     ...
 
   @overload
@@ -12338,7 +12328,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DiagnoseIfAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DiagnoseIfAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DiagnoseIfAttr]:
     ...
 
   @overload
@@ -12400,7 +12390,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DiagnoseAsBuiltinAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DiagnoseAsBuiltinAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DiagnoseAsBuiltinAttr]:
     ...
 
   @overload
@@ -12461,7 +12451,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DestructorAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DestructorAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DestructorAttr]:
     ...
 
   @overload
@@ -12526,7 +12516,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeprecatedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DeprecatedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeprecatedAttr]:
     ...
 
   @overload
@@ -12583,7 +12573,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclOrStmtAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DeclOrStmtAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeclOrStmtAttr]:
     ...
 
   @overload
@@ -12646,7 +12636,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlwaysInlineAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AlwaysInlineAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlwaysInlineAttr]:
     ...
 
   @overload
@@ -12708,7 +12698,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SuppressAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SuppressAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SuppressAttr]:
     ...
 
   @overload
@@ -12769,7 +12759,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoMergeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoMergeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoMergeAttr]:
     ...
 
   @overload
@@ -12831,7 +12821,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoInlineAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoInlineAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoInlineAttr]:
     ...
 
   @overload
@@ -12892,7 +12882,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DLLImportStaticLoca
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DLLImportStaticLocalAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DLLImportStaticLocalAttr]:
     ...
 
   @overload
@@ -12953,7 +12943,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DLLImportAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DLLImportAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DLLImportAttr]:
     ...
 
   @overload
@@ -13014,7 +13004,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DLLExportStaticLoca
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DLLExportStaticLocalAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DLLExportStaticLocalAttr]:
     ...
 
   @overload
@@ -13075,7 +13065,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DLLExportAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DLLExportAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DLLExportAttr]:
     ...
 
   @overload
@@ -13137,7 +13127,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CountedByAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CountedByAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CountedByAttr]:
     ...
 
   @overload
@@ -13198,7 +13188,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroWrapperAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoroWrapperAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroWrapperAttr]:
     ...
 
   @overload
@@ -13259,7 +13249,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroReturnTypeAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoroReturnTypeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroReturnTypeAttr]:
     ...
 
   @overload
@@ -13320,7 +13310,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroOnlyDestroyWhen
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoroOnlyDestroyWhenCompleteAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroOnlyDestroyWhenCompleteAttr]:
     ...
 
   @overload
@@ -13381,7 +13371,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroLifetimeBoundAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoroLifetimeBoundAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroLifetimeBoundAttr]:
     ...
 
   @overload
@@ -13442,7 +13432,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroDisableLifetime
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoroDisableLifetimeBoundAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroDisableLifetimeBoundAttr]:
     ...
 
   @overload
@@ -13503,7 +13493,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConvergentAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConvergentAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConvergentAttr]:
     ...
 
   @overload
@@ -13564,7 +13554,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConsumableSetOnRead
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConsumableSetOnReadAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConsumableSetOnReadAttr]:
     ...
 
   @overload
@@ -13625,7 +13615,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConsumableAutoCastA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConsumableAutoCastAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConsumableAutoCastAttr]:
     ...
 
   @overload
@@ -13687,7 +13677,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConsumableAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConsumableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConsumableAttr]:
     ...
 
   @overload
@@ -13748,7 +13738,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstructorAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConstructorAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstructorAttr]:
     ...
 
   @overload
@@ -13811,7 +13801,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstInitAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConstInitAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstInitAttr]:
     ...
 
   @overload
@@ -13872,7 +13862,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConstAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstAttr]:
     ...
 
   @overload
@@ -13933,7 +13923,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CommonAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CommonAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CommonAttr]:
     ...
 
   @overload
@@ -13994,7 +13984,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ColdAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ColdAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ColdAttr]:
     ...
 
   @overload
@@ -14057,7 +14047,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CodeSegAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CodeSegAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CodeSegAttr]:
     ...
 
   @overload
@@ -14118,7 +14108,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CodeModelAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CodeModelAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CodeModelAttr]:
     ...
 
   @overload
@@ -14179,7 +14169,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CmseNSEntryAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CmseNSEntryAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CmseNSEntryAttr]:
     ...
 
   @overload
@@ -14241,7 +14231,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CleanupAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CleanupAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CleanupAttr]:
     ...
 
   @overload
@@ -14302,7 +14292,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapturedRecordAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CapturedRecordAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CapturedRecordAttr]:
     ...
 
   @overload
@@ -14367,7 +14357,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapabilityAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CapabilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CapabilityAttr]:
     ...
 
   @overload
@@ -14428,7 +14418,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CallbackAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CallbackAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CallbackAttr]:
     ...
 
   @overload
@@ -14489,7 +14479,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CallableWhenAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CallableWhenAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CallableWhenAttr]:
     ...
 
   @overload
@@ -14551,7 +14541,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXX11NoReturnAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXX11NoReturnAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXX11NoReturnAttr]:
     ...
 
   @overload
@@ -14612,7 +14602,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDASharedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDASharedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDASharedAttr]:
     ...
 
   @overload
@@ -14676,7 +14666,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDALaunchBoundsAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDALaunchBoundsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDALaunchBoundsAttr]:
     ...
 
   @overload
@@ -14737,7 +14727,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAInvalidTargetAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDAInvalidTargetAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAInvalidTargetAttr]:
     ...
 
   @overload
@@ -14798,7 +14788,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAHostAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDAHostAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAHostAttr]:
     ...
 
   @overload
@@ -14859,7 +14849,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAGlobalAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDAGlobalAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAGlobalAttr]:
     ...
 
   @overload
@@ -14920,7 +14910,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDADeviceBuiltinTe
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDADeviceBuiltinTextureTypeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDADeviceBuiltinTextureTypeAttr]:
     ...
 
   @overload
@@ -14981,7 +14971,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDADeviceBuiltinSu
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDADeviceBuiltinSurfaceTypeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDADeviceBuiltinSurfaceTypeAttr]:
     ...
 
   @overload
@@ -15042,7 +15032,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDADeviceAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDADeviceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDADeviceAttr]:
     ...
 
   @overload
@@ -15103,7 +15093,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAConstantAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDAConstantAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAConstantAttr]:
     ...
 
   @overload
@@ -15164,7 +15154,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CPUSpecificAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CPUSpecificAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CPUSpecificAttr]:
     ...
 
   @overload
@@ -15225,7 +15215,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CPUDispatchAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CPUDispatchAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CPUDispatchAttr]:
     ...
 
   @overload
@@ -15286,7 +15276,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFUnknownTransferAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CFUnknownTransferAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFUnknownTransferAttr]:
     ...
 
   @overload
@@ -15347,7 +15337,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFReturnsRetainedAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CFReturnsRetainedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFReturnsRetainedAttr]:
     ...
 
   @overload
@@ -15408,7 +15398,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFReturnsNotRetaine
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CFReturnsNotRetainedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFReturnsNotRetainedAttr]:
     ...
 
   @overload
@@ -15469,7 +15459,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFICanonicalJumpTab
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CFICanonicalJumpTableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFICanonicalJumpTableAttr]:
     ...
 
   @overload
@@ -15531,7 +15521,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFGuardAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CFGuardAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFGuardAttr]:
     ...
 
   @overload
@@ -15592,7 +15582,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFAuditedTransferAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CFAuditedTransferAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFAuditedTransferAttr]:
     ...
 
   @overload
@@ -15653,7 +15643,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CDeclAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CDeclAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CDeclAttr]:
     ...
 
   @overload
@@ -15714,7 +15704,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.C11NoReturnAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.C11NoReturnAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.C11NoReturnAttr]:
     ...
 
   @overload
@@ -15775,7 +15765,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BuiltinAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinAttr]:
     ...
 
   @overload
@@ -15837,7 +15827,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlocksAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BlocksAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BlocksAttr]:
     ...
 
   @overload
@@ -15900,7 +15890,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BTFDeclTagAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BTFDeclTagAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BTFDeclTagAttr]:
     ...
 
   @overload
@@ -15961,7 +15951,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BPFPreserveStaticOf
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BPFPreserveStaticOffsetAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BPFPreserveStaticOffsetAttr]:
     ...
 
   @overload
@@ -16022,7 +16012,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BPFPreserveAccessIn
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BPFPreserveAccessIndexAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BPFPreserveAccessIndexAttr]:
     ...
 
   @overload
@@ -16083,7 +16073,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AvailableOnlyInDefa
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AvailableOnlyInDefaultEvalMethodAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AvailableOnlyInDefaultEvalMethodAttr]:
     ...
 
   @overload
@@ -16150,7 +16140,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AvailabilityAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AvailabilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AvailabilityAttr]:
     ...
 
   @overload
@@ -16213,7 +16203,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssumptionAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AssumptionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssumptionAttr]:
     ...
 
   @overload
@@ -16276,7 +16266,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssumeAlignedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AssumeAlignedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssumeAlignedAttr]:
     ...
 
   @overload
@@ -16337,7 +16327,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssertSharedLockAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AssertSharedLockAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssertSharedLockAttr]:
     ...
 
   @overload
@@ -16398,7 +16388,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssertExclusiveLock
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AssertExclusiveLockAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssertExclusiveLockAttr]:
     ...
 
   @overload
@@ -16461,7 +16451,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AssertCapabilityAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AssertCapabilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AssertCapabilityAttr]:
     ...
 
   @overload
@@ -16525,7 +16515,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AsmLabelAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AsmLabelAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AsmLabelAttr]:
     ...
 
   @overload
@@ -16586,7 +16576,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArtificialAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArtificialAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArtificialAttr]:
     ...
 
   @overload
@@ -16649,7 +16639,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmNewAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmNewAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmNewAttr]:
     ...
 
   @overload
@@ -16710,7 +16700,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmLocallyStreaming
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmLocallyStreamingAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmLocallyStreamingAttr]:
     ...
 
   @overload
@@ -16771,7 +16761,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArmBuiltinAliasAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArmBuiltinAliasAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArmBuiltinAliasAttr]:
     ...
 
   @overload
@@ -16834,7 +16824,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArgumentWithTypeTag
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArgumentWithTypeTagAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArgumentWithTypeTagAttr]:
     ...
 
   @overload
@@ -16895,7 +16885,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArcWeakrefUnavailab
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArcWeakrefUnavailableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArcWeakrefUnavailableAttr]:
     ...
 
   @overload
@@ -16956,7 +16946,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnyX86NoCfCheckAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AnyX86NoCfCheckAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnyX86NoCfCheckAttr]:
     ...
 
   @overload
@@ -17017,7 +17007,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnyX86NoCallerSaved
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AnyX86NoCallerSavedRegistersAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnyX86NoCallerSavedRegistersAttr]:
     ...
 
   @overload
@@ -17078,7 +17068,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnyX86InterruptAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AnyX86InterruptAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnyX86InterruptAttr]:
     ...
 
   @overload
@@ -17139,7 +17129,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnalyzerNoReturnAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AnalyzerNoReturnAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnalyzerNoReturnAttr]:
     ...
 
   @overload
@@ -17200,7 +17190,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlwaysDestroyAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AlwaysDestroyAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlwaysDestroyAttr]:
     ...
 
   @overload
@@ -17261,7 +17251,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AllocSizeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AllocSizeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AllocSizeAttr]:
     ...
 
   @overload
@@ -17322,7 +17312,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AllocAlignAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AllocAlignAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AllocAlignAttr]:
     ...
 
   @overload
@@ -17395,7 +17385,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlignedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AlignedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlignedAttr]:
     ...
 
   @overload
@@ -17456,7 +17446,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlignNaturalAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AlignNaturalAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlignNaturalAttr]:
     ...
 
   @overload
@@ -17517,7 +17507,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AlignMac68kAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AlignMac68kAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AlignMac68kAttr]:
     ...
 
   @overload
@@ -17578,7 +17568,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AcquiredBeforeAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AcquiredBeforeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AcquiredBeforeAttr]:
     ...
 
   @overload
@@ -17639,7 +17629,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AcquiredAfterAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AcquiredAfterAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AcquiredAfterAttr]:
     ...
 
   @overload
@@ -17702,7 +17692,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AcquireHandleAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AcquireHandleAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AcquireHandleAttr]:
     ...
 
   @overload
@@ -17765,7 +17755,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AcquireCapabilityAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AcquireCapabilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AcquireCapabilityAttr]:
     ...
 
   @overload
@@ -17826,7 +17816,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AVRSignalAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AVRSignalAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AVRSignalAttr]:
     ...
 
   @overload
@@ -17887,7 +17877,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AVRInterruptAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AVRInterruptAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AVRInterruptAttr]:
     ...
 
   @overload
@@ -17949,7 +17939,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ARMInterruptAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ARMInterruptAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ARMInterruptAttr]:
     ...
 
   @overload
@@ -18012,7 +18002,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUWavesPerEUAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AMDGPUWavesPerEUAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUWavesPerEUAttr]:
     ...
 
   @overload
@@ -18074,7 +18064,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUNumVGPRAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AMDGPUNumVGPRAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUNumVGPRAttr]:
     ...
 
   @overload
@@ -18136,7 +18126,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUNumSGPRAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AMDGPUNumSGPRAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUNumSGPRAttr]:
     ...
 
   @overload
@@ -18197,7 +18187,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUKernelCallAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AMDGPUKernelCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUKernelCallAttr]:
     ...
 
   @overload
@@ -18260,7 +18250,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AMDGPUFlatWorkGroup
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AMDGPUFlatWorkGroupSizeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AMDGPUFlatWorkGroupSizeAttr]:
     ...
 
   @overload
@@ -18321,7 +18311,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AArch64VectorPcsAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AArch64VectorPcsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AArch64VectorPcsAttr]:
     ...
 
   @overload
@@ -18382,7 +18372,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AArch64SVEPcsAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AArch64SVEPcsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AArch64SVEPcsAttr]:
     ...
 
   @overload
@@ -18444,7 +18434,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ZeroCallUsedRegsAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ZeroCallUsedRegsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ZeroCallUsedRegsAttr]:
     ...
 
   @overload
@@ -18506,7 +18496,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.XRayLogArgsAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.XRayLogArgsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.XRayLogArgsAttr]:
     ...
 
   @overload
@@ -18570,7 +18560,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.XRayInstrumentAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.XRayInstrumentAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.XRayInstrumentAttr]:
     ...
 
   @overload
@@ -18631,7 +18621,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.X86ForceAlignArgPoi
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.X86ForceAlignArgPointerAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.X86ForceAlignArgPointerAttr]:
     ...
 
   @overload
@@ -18695,7 +18685,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WorkGroupSizeHintAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WorkGroupSizeHintAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WorkGroupSizeHintAttr]:
     ...
 
   @overload
@@ -18758,7 +18748,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WebAssemblyImportNa
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WebAssemblyImportNameAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WebAssemblyImportNameAttr]:
     ...
 
   @overload
@@ -18821,7 +18811,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WebAssemblyImportMo
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WebAssemblyImportModuleAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WebAssemblyImportModuleAttr]:
     ...
 
   @overload
@@ -18884,7 +18874,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WebAssemblyExportNa
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WebAssemblyExportNameAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WebAssemblyExportNameAttr]:
     ...
 
   @overload
@@ -18947,7 +18937,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WeakRefAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WeakRefAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WeakRefAttr]:
     ...
 
   @overload
@@ -19008,7 +18998,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WeakImportAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WeakImportAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WeakImportAttr]:
     ...
 
   @overload
@@ -19069,7 +19059,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WeakAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WeakAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WeakAttr]:
     ...
 
   @overload
@@ -19134,7 +19124,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WarnUnusedResultAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WarnUnusedResultAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WarnUnusedResultAttr]:
     ...
 
   @overload
@@ -19195,7 +19185,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WarnUnusedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WarnUnusedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WarnUnusedAttr]:
     ...
 
   @overload
@@ -19257,7 +19247,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VisibilityAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VisibilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VisibilityAttr]:
     ...
 
   @overload
@@ -19318,7 +19308,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VectorCallAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VectorCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VectorCallAttr]:
     ...
 
   @overload
@@ -19381,7 +19371,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VecTypeHintAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VecTypeHintAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VecTypeHintAttr]:
     ...
 
   @overload
@@ -19442,7 +19432,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VecReturnAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VecReturnAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VecReturnAttr]:
     ...
 
   @overload
@@ -19506,7 +19496,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UuidAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UuidAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UuidAttr]:
     ...
 
   @overload
@@ -19567,7 +19557,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingIfExistsAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UsingIfExistsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingIfExistsAttr]:
     ...
 
   @overload
@@ -19628,7 +19618,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UsedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsedAttr]:
     ...
 
   @overload
@@ -19690,7 +19680,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnusedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnusedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnusedAttr]:
     ...
 
   @overload
@@ -19751,7 +19741,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnsafeBufferUsageAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnsafeBufferUsageAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnsafeBufferUsageAttr]:
     ...
 
   @overload
@@ -19812,7 +19802,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UninitializedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UninitializedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UninitializedAttr]:
     ...
 
   @overload
@@ -19876,7 +19866,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnavailableAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnavailableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnavailableAttr]:
     ...
 
   @overload
@@ -19938,7 +19928,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeVisibilityAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeVisibilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeVisibilityAttr]:
     ...
 
   @overload
@@ -20003,7 +19993,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeTagForDatatypeA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeTagForDatatypeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeTagForDatatypeAttr]:
     ...
 
   @overload
@@ -20067,7 +20057,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TryAcquireCapabilit
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TryAcquireCapabilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TryAcquireCapabilityAttr]:
     ...
 
   @overload
@@ -20128,7 +20118,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TrivialABIAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TrivialABIAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TrivialABIAttr]:
     ...
 
   @overload
@@ -20189,7 +20179,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TransparentUnionAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TransparentUnionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TransparentUnionAttr]:
     ...
 
   @overload
@@ -20250,7 +20240,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ThisCallAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ThisCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ThisCallAttr]:
     ...
 
   @overload
@@ -20312,7 +20302,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TestTypestateAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TestTypestateAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TestTypestateAttr]:
     ...
 
   @overload
@@ -20377,7 +20367,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TargetVersionAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TargetVersionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TargetVersionAttr]:
     ...
 
   @overload
@@ -20438,7 +20428,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TargetClonesAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TargetClonesAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TargetClonesAttr]:
     ...
 
   @overload
@@ -20503,7 +20493,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TargetAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TargetAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TargetAttr]:
     ...
 
   @overload
@@ -20566,7 +20556,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TLSModelAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TLSModelAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TLSModelAttr]:
     ...
 
   @overload
@@ -20627,7 +20617,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SysVABIAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SysVABIAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SysVABIAttr]:
     ...
 
   @overload
@@ -20688,7 +20678,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftPrivateAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftPrivateAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftPrivateAttr]:
     ...
 
   @overload
@@ -20751,7 +20741,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftNewTypeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftNewTypeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftNewTypeAttr]:
     ...
 
   @overload
@@ -20814,7 +20804,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftNameAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftNameAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftNameAttr]:
     ...
 
   @overload
@@ -20875,7 +20865,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftImportProperty
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftImportPropertyAsAccessorsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftImportPropertyAsAccessorsAttr]:
     ...
 
   @overload
@@ -20936,7 +20926,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftImportAsNonGen
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftImportAsNonGenericAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftImportAsNonGenericAttr]:
     ...
 
   @overload
@@ -20998,7 +20988,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftErrorAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftErrorAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftErrorAttr]:
     ...
 
   @overload
@@ -21059,7 +21049,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftCallAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftCallAttr]:
     ...
 
   @overload
@@ -21120,7 +21110,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftBridgedTypedef
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftBridgedTypedefAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftBridgedTypedefAttr]:
     ...
 
   @overload
@@ -21183,7 +21173,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftBridgeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftBridgeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftBridgeAttr]:
     ...
 
   @overload
@@ -21246,7 +21236,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAttrAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftAttrAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAttrAttr]:
     ...
 
   @overload
@@ -21309,7 +21299,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncNameAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftAsyncNameAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncNameAttr]:
     ...
 
   @overload
@@ -21372,7 +21362,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncErrorAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftAsyncErrorAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncErrorAttr]:
     ...
 
   @overload
@@ -21433,7 +21423,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncCallAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftAsyncCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncCallAttr]:
     ...
 
   @overload
@@ -21495,7 +21485,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftAsyncAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncAttr]:
     ...
 
   @overload
@@ -21556,7 +21546,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StrictGuardStackChe
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.StrictGuardStackCheckAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StrictGuardStackCheckAttr]:
     ...
 
   @overload
@@ -21617,7 +21607,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StrictFPAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.StrictFPAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StrictFPAttr]:
     ...
 
   @overload
@@ -21678,7 +21668,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StdCallAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.StdCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StdCallAttr]:
     ...
 
   @overload
@@ -21739,7 +21729,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StandaloneDebugAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.StandaloneDebugAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StandaloneDebugAttr]:
     ...
 
   @overload
@@ -21800,7 +21790,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SpeculativeLoadHard
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SpeculativeLoadHardeningAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SpeculativeLoadHardeningAttr]:
     ...
 
   @overload
@@ -21862,7 +21852,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SharedTrylockFuncti
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SharedTrylockFunctionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SharedTrylockFunctionAttr]:
     ...
 
   @overload
@@ -21924,7 +21914,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SetTypestateAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SetTypestateAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SetTypestateAttr]:
     ...
 
   @overload
@@ -21985,7 +21975,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SentinelAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SentinelAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SentinelAttr]:
     ...
 
   @overload
@@ -22046,7 +22036,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SelectAnyAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SelectAnyAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SelectAnyAttr]:
     ...
 
   @overload
@@ -22110,7 +22100,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SectionAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SectionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SectionAttr]:
     ...
 
   @overload
@@ -22171,7 +22161,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ScopedLockableAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ScopedLockableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ScopedLockableAttr]:
     ...
 
   @overload
@@ -22232,7 +22222,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SYCLSpecialClassAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SYCLSpecialClassAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SYCLSpecialClassAttr]:
     ...
 
   @overload
@@ -22293,7 +22283,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SYCLKernelAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SYCLKernelAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SYCLKernelAttr]:
     ...
 
   @overload
@@ -22354,7 +22344,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReturnsTwiceAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReturnsTwiceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReturnsTwiceAttr]:
     ...
 
   @overload
@@ -22415,7 +22405,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReturnsNonNullAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReturnsNonNullAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReturnsNonNullAttr]:
     ...
 
   @overload
@@ -22477,7 +22467,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReturnTypestateAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReturnTypestateAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReturnTypestateAttr]:
     ...
 
   @overload
@@ -22538,7 +22528,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RetainAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RetainAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RetainAttr]:
     ...
 
   @overload
@@ -22600,7 +22590,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RestrictAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RestrictAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RestrictAttr]:
     ...
 
   @overload
@@ -22663,7 +22653,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RequiresCapabilityA
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RequiresCapabilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RequiresCapabilityAttr]:
     ...
 
   @overload
@@ -22727,7 +22717,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReqdWorkGroupSizeAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReqdWorkGroupSizeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReqdWorkGroupSizeAttr]:
     ...
 
   @overload
@@ -22791,7 +22781,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReleaseCapabilityAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReleaseCapabilityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReleaseCapabilityAttr]:
     ...
 
   @overload
@@ -22852,7 +22842,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReinitializesAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReinitializesAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReinitializesAttr]:
     ...
 
   @overload
@@ -22913,7 +22903,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RegCallAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RegCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RegCallAttr]:
     ...
 
   @overload
@@ -22974,7 +22964,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReadOnlyPlacementAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReadOnlyPlacementAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReadOnlyPlacementAttr]:
     ...
 
   @overload
@@ -23035,7 +23025,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RandomizeLayoutAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RandomizeLayoutAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RandomizeLayoutAttr]:
     ...
 
   @overload
@@ -23097,7 +23087,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RISCVInterruptAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RISCVInterruptAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RISCVInterruptAttr]:
     ...
 
   @overload
@@ -23158,7 +23148,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PureAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PureAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PureAttr]:
     ...
 
   @overload
@@ -23219,7 +23209,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PtGuardedVarAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PtGuardedVarAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PtGuardedVarAttr]:
     ...
 
   @overload
@@ -23281,7 +23271,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PtGuardedByAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PtGuardedByAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PtGuardedByAttr]:
     ...
 
   @overload
@@ -23342,7 +23332,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PreserveMostAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PreserveMostAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PreserveMostAttr]:
     ...
 
   @overload
@@ -23403,7 +23393,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PreserveAllAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PreserveAllAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PreserveAllAttr]:
     ...
 
   @overload
@@ -23466,7 +23456,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PreferredTypeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PreferredTypeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PreferredTypeAttr]:
     ...
 
   @overload
@@ -23529,7 +23519,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PreferredNameAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PreferredNameAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PreferredNameAttr]:
     ...
 
   @overload
@@ -23592,7 +23582,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangTextSect
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PragmaClangTextSectionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangTextSectionAttr]:
     ...
 
   @overload
@@ -23655,7 +23645,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangRodataSe
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PragmaClangRodataSectionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangRodataSectionAttr]:
     ...
 
   @overload
@@ -23718,7 +23708,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangRelroSec
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PragmaClangRelroSectionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangRelroSectionAttr]:
     ...
 
   @overload
@@ -23781,7 +23771,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangDataSect
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PragmaClangDataSectionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangDataSectionAttr]:
     ...
 
   @overload
@@ -23844,7 +23834,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaClangBSSSecti
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PragmaClangBSSSectionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaClangBSSSectionAttr]:
     ...
 
   @overload
@@ -23907,7 +23897,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PointerAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PointerAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PointerAttr]:
     ...
 
   @overload
@@ -23969,7 +23959,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PcsAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PcsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PcsAttr]:
     ...
 
   @overload
@@ -24031,7 +24021,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PatchableFunctionEn
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PatchableFunctionEntryAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PatchableFunctionEntryAttr]:
     ...
 
   @overload
@@ -24092,7 +24082,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PascalAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PascalAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PascalAttr]:
     ...
 
   @overload
@@ -24154,7 +24144,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParamTypestateAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ParamTypestateAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParamTypestateAttr]:
     ...
 
   @overload
@@ -24215,7 +24205,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PackedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PackedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PackedAttr]:
     ...
 
   @overload
@@ -24281,7 +24271,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OwnershipAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OwnershipAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OwnershipAttr]:
     ...
 
   @overload
@@ -24344,7 +24334,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OwnerAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OwnerAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OwnerAttr]:
     ...
 
   @overload
@@ -24405,7 +24395,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OverrideAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OverrideAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OverrideAttr]:
     ...
 
   @overload
@@ -24466,7 +24456,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OptimizeNoneAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OptimizeNoneAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OptimizeNoneAttr]:
     ...
 
   @overload
@@ -24527,7 +24517,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLKernelAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLKernelAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLKernelAttr]:
     ...
 
   @overload
@@ -24589,7 +24579,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpenCLIntelReqdSubG
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpenCLIntelReqdSubGroupSizeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpenCLIntelReqdSubGroupSizeAttr]:
     ...
 
   @overload
@@ -24650,7 +24640,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCSubclassingRest
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCSubclassingRestrictedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCSubclassingRestrictedAttr]:
     ...
 
   @overload
@@ -24711,7 +24701,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRootClassAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCRootClassAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRootClassAttr]:
     ...
 
   @overload
@@ -24772,7 +24762,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCReturnsInnerPoi
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCReturnsInnerPointerAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCReturnsInnerPointerAttr]:
     ...
 
   @overload
@@ -24833,7 +24823,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRequiresSuperAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCRequiresSuperAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRequiresSuperAttr]:
     ...
 
   @overload
@@ -24894,7 +24884,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCRequiresPropert
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCRequiresPropertyDefsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCRequiresPropertyDefsAttr]:
     ...
 
   @overload
@@ -24955,7 +24945,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPreciseLifetime
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCPreciseLifetimeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCPreciseLifetimeAttr]:
     ...
 
   @overload
@@ -25016,7 +25006,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCOwnershipAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCOwnershipAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCOwnershipAttr]:
     ...
 
   @overload
@@ -25077,7 +25067,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCNSObjectAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCNSObjectAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCNSObjectAttr]:
     ...
 
   @overload
@@ -25139,7 +25129,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCMethodFamilyAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCMethodFamilyAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCMethodFamilyAttr]:
     ...
 
   @overload
@@ -25200,7 +25190,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIndependentClas
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCIndependentClassAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIndependentClassAttr]:
     ...
 
   @overload
@@ -25261,7 +25251,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCExternallyRetai
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCExternallyRetainedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCExternallyRetainedAttr]:
     ...
 
   @overload
@@ -25322,7 +25312,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCExplicitProtoco
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCExplicitProtocolImplAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCExplicitProtocolImplAttr]:
     ...
 
   @overload
@@ -25383,7 +25373,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCExceptionAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCExceptionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCExceptionAttr]:
     ...
 
   @overload
@@ -25444,7 +25434,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBridgeRelatedAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCBridgeRelatedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBridgeRelatedAttr]:
     ...
 
   @overload
@@ -25505,7 +25495,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBridgeMutableAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCBridgeMutableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBridgeMutableAttr]:
     ...
 
   @overload
@@ -25566,7 +25556,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBridgeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCBridgeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBridgeAttr]:
     ...
 
   @overload
@@ -25627,7 +25617,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSReturnsRetainedOn
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OSReturnsRetainedOnZeroAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSReturnsRetainedOnZeroAttr]:
     ...
 
   @overload
@@ -25688,7 +25678,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSReturnsRetainedOn
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OSReturnsRetainedOnNonZeroAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSReturnsRetainedOnNonZeroAttr]:
     ...
 
   @overload
@@ -25749,7 +25739,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSReturnsRetainedAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OSReturnsRetainedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSReturnsRetainedAttr]:
     ...
 
   @overload
@@ -25810,7 +25800,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSReturnsNotRetaine
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OSReturnsNotRetainedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSReturnsNotRetainedAttr]:
     ...
 
   @overload
@@ -25871,7 +25861,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSConsumesThisAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OSConsumesThisAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSConsumesThisAttr]:
     ...
 
   @overload
@@ -25932,7 +25922,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPThreadPrivateDec
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPThreadPrivateDeclAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPThreadPrivateDeclAttr]:
     ...
 
   @overload
@@ -25994,7 +25984,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareVariantAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDeclareVariantAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareVariantAttr]:
     ...
 
   @overload
@@ -26060,7 +26050,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareTargetDec
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDeclareTargetDeclAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareTargetDeclAttr]:
     ...
 
   @overload
@@ -26121,7 +26111,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCaptureNoInitAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPCaptureNoInitAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCaptureNoInitAttr]:
     ...
 
   @overload
@@ -26185,7 +26175,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPAllocateDeclAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPAllocateDeclAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPAllocateDeclAttr]:
     ...
 
   @overload
@@ -26246,7 +26236,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NotTailCalledAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NotTailCalledAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NotTailCalledAttr]:
     ...
 
   @overload
@@ -26307,7 +26297,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoUwtableAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoUwtableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoUwtableAttr]:
     ...
 
   @overload
@@ -26368,7 +26358,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoUniqueAddressAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoUniqueAddressAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoUniqueAddressAttr]:
     ...
 
   @overload
@@ -26429,7 +26419,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoThrowAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoThrowAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoThrowAttr]:
     ...
 
   @overload
@@ -26490,7 +26480,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoThreadSafetyAnaly
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoThreadSafetyAnalysisAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoThreadSafetyAnalysisAttr]:
     ...
 
   @overload
@@ -26552,7 +26542,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoStackProtectorAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoStackProtectorAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoStackProtectorAttr]:
     ...
 
   @overload
@@ -26613,7 +26603,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoSplitStackAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoSplitStackAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoSplitStackAttr]:
     ...
 
   @overload
@@ -26674,7 +26664,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoSpeculativeLoadHa
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoSpeculativeLoadHardeningAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoSpeculativeLoadHardeningAttr]:
     ...
 
   @overload
@@ -26736,7 +26726,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoSanitizeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoSanitizeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoSanitizeAttr]:
     ...
 
   @overload
@@ -26797,7 +26787,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoReturnAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoReturnAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoReturnAttr]:
     ...
 
   @overload
@@ -26858,7 +26848,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoRandomizeLayoutAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoRandomizeLayoutAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoRandomizeLayoutAttr]:
     ...
 
   @overload
@@ -26919,7 +26909,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoProfileFunctionAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoProfileFunctionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoProfileFunctionAttr]:
     ...
 
   @overload
@@ -26980,7 +26970,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoMips16Attr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoMips16Attr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoMips16Attr]:
     ...
 
   @overload
@@ -27041,7 +27031,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoMicroMipsAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoMicroMipsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoMicroMipsAttr]:
     ...
 
   @overload
@@ -27102,7 +27092,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoInstrumentFunctio
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoInstrumentFunctionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoInstrumentFunctionAttr]:
     ...
 
   @overload
@@ -27163,7 +27153,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoDuplicateAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoDuplicateAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoDuplicateAttr]:
     ...
 
   @overload
@@ -27224,7 +27214,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoDestroyAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoDestroyAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoDestroyAttr]:
     ...
 
   @overload
@@ -27285,7 +27275,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoDebugAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoDebugAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoDebugAttr]:
     ...
 
   @overload
@@ -27346,7 +27336,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoCommonAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoCommonAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoCommonAttr]:
     ...
 
   @overload
@@ -27407,7 +27397,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoAliasAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoAliasAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoAliasAttr]:
     ...
 
   @overload
@@ -27468,7 +27458,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NakedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NakedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NakedAttr]:
     ...
 
   @overload
@@ -27529,7 +27519,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NVPTXKernelAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NVPTXKernelAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NVPTXKernelAttr]:
     ...
 
   @overload
@@ -27590,7 +27580,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSReturnsRetainedAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NSReturnsRetainedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSReturnsRetainedAttr]:
     ...
 
   @overload
@@ -27651,7 +27641,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSReturnsNotRetaine
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NSReturnsNotRetainedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSReturnsNotRetainedAttr]:
     ...
 
   @overload
@@ -27712,7 +27702,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSReturnsAutoreleas
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NSReturnsAutoreleasedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSReturnsAutoreleasedAttr]:
     ...
 
   @overload
@@ -27773,7 +27763,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSErrorDomainAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NSErrorDomainAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSErrorDomainAttr]:
     ...
 
   @overload
@@ -27834,7 +27824,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSConsumesSelfAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NSConsumesSelfAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSConsumesSelfAttr]:
     ...
 
   @overload
@@ -27896,7 +27886,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MipsShortCallAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MipsShortCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MipsShortCallAttr]:
     ...
 
   @overload
@@ -27958,7 +27948,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MipsLongCallAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MipsLongCallAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MipsLongCallAttr]:
     ...
 
   @overload
@@ -28020,7 +28010,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MipsInterruptAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MipsInterruptAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MipsInterruptAttr]:
     ...
 
   @overload
@@ -28081,7 +28071,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Mips16Attr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.Mips16Attr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Mips16Attr]:
     ...
 
   @overload
@@ -28143,7 +28133,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MinVectorWidthAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MinVectorWidthAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MinVectorWidthAttr]:
     ...
 
   @overload
@@ -28204,7 +28194,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MinSizeAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MinSizeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MinSizeAttr]:
     ...
 
   @overload
@@ -28265,7 +28255,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MicroMipsAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MicroMipsAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MicroMipsAttr]:
     ...
 
   @overload
@@ -28326,7 +28316,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MaybeUndefAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MaybeUndefAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MaybeUndefAttr]:
     ...
 
   @overload
@@ -28387,7 +28377,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MayAliasAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MayAliasAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MayAliasAttr]:
     ...
 
   @overload
@@ -28449,7 +28439,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MaxFieldAlignmentAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MaxFieldAlignmentAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MaxFieldAlignmentAttr]:
     ...
 
   @overload
@@ -28512,7 +28502,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSVtorDispAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSVtorDispAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSVtorDispAttr]:
     ...
 
   @overload
@@ -28573,7 +28563,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSStructAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSStructAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSStructAttr]:
     ...
 
   @overload
@@ -28635,7 +28625,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSP430InterruptAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSP430InterruptAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSP430InterruptAttr]:
     ...
 
   @overload
@@ -28696,7 +28686,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSNoVTableAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSNoVTableAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSNoVTableAttr]:
     ...
 
   @overload
@@ -28760,7 +28750,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSInheritanceAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSInheritanceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSInheritanceAttr]:
     ...
 
   @overload
@@ -28821,7 +28811,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSConstexprAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSConstexprAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSConstexprAttr]:
     ...
 
   @overload
@@ -28882,7 +28872,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSAllocatorAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSAllocatorAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSAllocatorAttr]:
     ...
 
   @overload
@@ -28943,7 +28933,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSABIAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSABIAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSABIAttr]:
     ...
 
   @overload
@@ -29004,7 +28994,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MIGServerRoutineAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MIGServerRoutineAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MIGServerRoutineAttr]:
     ...
 
   @overload
@@ -29065,7 +29055,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.M68kRTDAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.M68kRTDAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.M68kRTDAttr]:
     ...
 
   @overload
@@ -29127,7 +29117,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.M68kInterruptAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.M68kInterruptAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.M68kInterruptAttr]:
     ...
 
   @overload
@@ -29188,7 +29178,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LocksExcludedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LocksExcludedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LocksExcludedAttr]:
     ...
 
   @overload
@@ -29250,7 +29240,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LockReturnedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LockReturnedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LockReturnedAttr]:
     ...
 
   @overload
@@ -29311,7 +29301,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LifetimeBoundAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LifetimeBoundAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LifetimeBoundAttr]:
     ...
 
   @overload
@@ -29372,7 +29362,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LeafAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LeafAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LeafAttr]:
     ...
 
   @overload
@@ -29434,7 +29424,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LayoutVersionAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LayoutVersionAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LayoutVersionAttr]:
     ...
 
   @overload
@@ -29495,7 +29485,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LTOVisibilityPublic
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LTOVisibilityPublicAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LTOVisibilityPublicAttr]:
     ...
 
   @overload
@@ -29556,7 +29546,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InternalLinkageAttr
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.InternalLinkageAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InternalLinkageAttr]:
     ...
 
   @overload
@@ -29617,7 +29607,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IntelOclBiccAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IntelOclBiccAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IntelOclBiccAttr]:
     ...
 
   @overload
@@ -29679,7 +29669,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InitPriorityAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.InitPriorityAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InitPriorityAttr]:
     ...
 
   @overload
@@ -29736,7 +29726,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InheritableParamAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.InheritableParamAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InheritableParamAttr]:
     ...
 
   @overload
@@ -29797,7 +29787,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CarriesDependencyAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CarriesDependencyAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CarriesDependencyAttr]:
     ...
 
   @overload
@@ -29858,7 +29848,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CFConsumedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CFConsumedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CFConsumedAttr]:
     ...
 
   @overload
@@ -29921,7 +29911,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AnnotateAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AnnotateAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AnnotateAttr]:
     ...
 
   @overload
@@ -29984,7 +29974,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UseHandleAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UseHandleAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UseHandleAttr]:
     ...
 
   @overload
@@ -30047,7 +30037,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReleaseHandleAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReleaseHandleAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReleaseHandleAttr]:
     ...
 
   @overload
@@ -30110,7 +30100,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PassObjectSizeAttr]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PassObjectSizeAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PassObjectSizeAttr]:
     ...
 
   @overload
@@ -30168,7 +30158,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParameterABIAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ParameterABIAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParameterABIAttr]:
     ...
 
   @overload
@@ -30229,7 +30219,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftIndirectResult
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftIndirectResultAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftIndirectResultAttr]:
     ...
 
   @overload
@@ -30290,7 +30280,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftErrorResultAtt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftErrorResultAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftErrorResultAttr]:
     ...
 
   @overload
@@ -30351,7 +30341,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftContextAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftContextAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftContextAttr]:
     ...
 
   @overload
@@ -30412,7 +30402,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwiftAsyncContextAt
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwiftAsyncContextAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwiftAsyncContextAttr]:
     ...
 
   @overload
@@ -30473,7 +30463,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OSConsumedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OSConsumedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OSConsumedAttr]:
     ...
 
   @overload
@@ -30534,7 +30524,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NonNullAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NonNullAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NonNullAttr]:
     ...
 
   @overload
@@ -30595,7 +30585,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NSConsumedAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NSConsumedAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NSConsumedAttr]:
     ...
 
   @overload
@@ -30658,7 +30648,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IFuncAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IFuncAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IFuncAttr]:
     ...
 
   @overload
@@ -30719,7 +30709,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CalledOnceAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CalledOnceAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CalledOnceAttr]:
     ...
 
   @overload
@@ -30781,7 +30771,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinAliasAttr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BuiltinAliasAttr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinAliasAttr]:
     ...
 
   @overload
@@ -30852,7 +30842,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Type]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.Type]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Type]:
     ...
 
   @overload
@@ -30907,7 +30897,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateTypeParmTyp
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TemplateTypeParmType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateTypeParmType]:
     ...
 
   @overload
@@ -30963,7 +30953,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateSpecializat
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TemplateSpecializationType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateSpecializationType]:
     ...
 
   @overload
@@ -31014,7 +31004,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TagType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TagType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TagType]:
     ...
 
   @overload
@@ -31066,7 +31056,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RecordType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RecordType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RecordType]:
     ...
 
   @overload
@@ -31117,7 +31107,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.EnumType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnumType]:
     ...
 
   @overload
@@ -31173,7 +31163,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstTemplateTypePa
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SubstTemplateTypeParmType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SubstTemplateTypeParmType]:
     ...
 
   @overload
@@ -31228,7 +31218,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstTemplateTypePa
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SubstTemplateTypeParmPackType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SubstTemplateTypeParmPackType]:
     ...
 
   @overload
@@ -31278,7 +31268,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReferenceType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReferenceType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReferenceType]:
     ...
 
   @overload
@@ -31329,7 +31319,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RValueReferenceType
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RValueReferenceType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RValueReferenceType]:
     ...
 
   @overload
@@ -31380,7 +31370,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LValueReferenceType
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LValueReferenceType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LValueReferenceType]:
     ...
 
   @overload
@@ -31466,7 +31456,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.QualifiedType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.QualifiedType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.QualifiedType]:
     ...
 
   @overload
@@ -31518,7 +31508,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PointerType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PointerType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PointerType]:
     ...
 
   @overload
@@ -31571,7 +31561,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PipeType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PipeType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PipeType]:
     ...
 
   @overload
@@ -31623,7 +31613,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParenType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ParenType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParenType]:
     ...
 
   @overload
@@ -31675,7 +31665,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PackExpansionType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PackExpansionType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PackExpansionType]:
     ...
 
   @overload
@@ -31727,7 +31717,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCTypeParamType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCTypeParamType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCTypeParamType]:
     ...
 
   @overload
@@ -31798,7 +31788,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCObjectType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCObjectType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCObjectType]:
     ...
 
   @overload
@@ -31852,7 +31842,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCInterfaceType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCInterfaceType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCInterfaceType]:
     ...
 
   @overload
@@ -31922,7 +31912,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCObjectPointerTy
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCObjectPointerType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCObjectPointerType]:
     ...
 
   @overload
@@ -31986,7 +31976,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MemberPointerType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MemberPointerType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MemberPointerType]:
     ...
 
   @overload
@@ -32034,7 +32024,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MatrixType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MatrixType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MatrixType]:
     ...
 
   @overload
@@ -32087,7 +32077,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentSizedMatri
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentSizedMatrixType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentSizedMatrixType]:
     ...
 
   @overload
@@ -32138,7 +32128,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstantMatrixType]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConstantMatrixType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstantMatrixType]:
     ...
 
   @overload
@@ -32191,7 +32181,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MacroQualifiedType]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MacroQualifiedType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MacroQualifiedType]:
     ...
 
   @overload
@@ -32245,7 +32235,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InjectedClassNameTy
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.InjectedClassNameType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InjectedClassNameType]:
     ...
 
   @overload
@@ -32301,7 +32291,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FunctionType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionType]:
     ...
 
   @overload
@@ -32374,7 +32364,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionProtoType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FunctionProtoType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionProtoType]:
     ...
 
   @overload
@@ -32431,7 +32421,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionNoProtoType
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FunctionNoProtoType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionNoProtoType]:
     ...
 
   @overload
@@ -32486,7 +32476,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentVectorType
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentVectorType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentVectorType]:
     ...
 
   @overload
@@ -32540,7 +32530,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentSizedExtVe
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentSizedExtVectorType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentSizedExtVectorType]:
     ...
 
   @overload
@@ -32594,7 +32584,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentBitIntType
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentBitIntType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentBitIntType]:
     ...
 
   @overload
@@ -32648,7 +32638,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentAddressSpa
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentAddressSpaceType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentAddressSpaceType]:
     ...
 
   @overload
@@ -32697,7 +32687,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeducedType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DeducedType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeducedType]:
     ...
 
   @overload
@@ -32747,7 +32737,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeducedTemplateSpec
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DeducedTemplateSpecializationType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeducedTemplateSpecializationType]:
     ...
 
   @overload
@@ -32804,7 +32794,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AutoType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AutoType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AutoType]:
     ...
 
   @overload
@@ -32860,7 +32850,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DecltypeType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DecltypeType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DecltypeType]:
     ...
 
   @overload
@@ -32912,7 +32902,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ComplexType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ComplexType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ComplexType]:
     ...
 
   @overload
@@ -32970,7 +32960,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BuiltinType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinType]:
     ...
 
   @overload
@@ -33022,7 +33012,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlockPointerType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BlockPointerType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BlockPointerType]:
     ...
 
   @overload
@@ -33075,7 +33065,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BitIntType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BitIntType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BitIntType]:
     ...
 
   @overload
@@ -33128,7 +33118,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BTFTagAttributedTyp
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BTFTagAttributedType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BTFTagAttributedType]:
     ...
 
   @overload
@@ -33189,7 +33179,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AttributedType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AttributedType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AttributedType]:
     ...
 
   @overload
@@ -33241,7 +33231,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AtomicType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AtomicType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AtomicType]:
     ...
 
   @overload
@@ -33290,7 +33280,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArrayType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArrayType]:
     ...
 
   @overload
@@ -33345,7 +33335,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VariableArrayType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VariableArrayType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VariableArrayType]:
     ...
 
   @overload
@@ -33396,7 +33386,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IncompleteArrayType
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IncompleteArrayType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IncompleteArrayType]:
     ...
 
   @overload
@@ -33451,7 +33441,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentSizedArray
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentSizedArrayType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentSizedArrayType]:
     ...
 
   @overload
@@ -33503,7 +33493,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstantArrayType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConstantArrayType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstantArrayType]:
     ...
 
   @overload
@@ -33556,7 +33546,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AdjustedType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AdjustedType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AdjustedType]:
     ...
 
   @overload
@@ -33607,7 +33597,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DecayedType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DecayedType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DecayedType]:
     ...
 
   @overload
@@ -33654,7 +33644,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeWithKeyword]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeWithKeyword]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeWithKeyword]:
     ...
 
   @overload
@@ -33707,7 +33697,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ElaboratedType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ElaboratedType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ElaboratedType]:
     ...
 
   @overload
@@ -33760,7 +33750,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentTemplateSp
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentTemplateSpecializationType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentTemplateSpecializationType]:
     ...
 
   @overload
@@ -33814,7 +33804,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentNameType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentNameType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentNameType]:
     ...
 
   @overload
@@ -33867,7 +33857,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VectorType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VectorType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VectorType]:
     ...
 
   @overload
@@ -33917,7 +33907,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExtVectorType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExtVectorType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExtVectorType]:
     ...
 
   @overload
@@ -33971,7 +33961,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UsingType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingType]:
     ...
 
   @overload
@@ -34023,7 +34013,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingType
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnresolvedUsingType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedUsingType]:
     ...
 
   @overload
@@ -34077,7 +34067,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnaryTransformType]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnaryTransformType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnaryTransformType]:
     ...
 
   @overload
@@ -34130,7 +34120,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypedefType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypedefType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypedefType]:
     ...
 
   @overload
@@ -34183,7 +34173,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeOfType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeOfType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeOfType]:
     ...
 
   @overload
@@ -34236,7 +34226,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeOfExprType]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeOfExprType]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeOfExprType]:
     ...
 
   @overload
@@ -34294,12 +34284,12 @@ def IN(file: multiplier.frontend.File, kinds: Sequence[multiplier.ast.StmtKind])
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.Stmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.Stmt]:
     ...
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation, kinds: Sequence[multiplier.ast.StmtKind]) -> Iterable[Tuple[multiplier.ast.Stmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation, kinds: Sequence[multiplier.ast.StmtKind]) -> Iterable[multiplier.ast.Stmt]:
     ...
 
   @overload
@@ -34327,9 +34317,8 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.Stmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.Stmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.Stmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.Stmt]:
     ...
 
   @overload
@@ -34349,7 +34338,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Stmt]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.Stmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Stmt]:
     ...
 
   @overload
@@ -34357,10 +34346,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.Stmt]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.Stmt]:
-    ...
-
 class SEHTryStmt(multiplier.ast.Stmt):
   except_handler: multiplier.ast.SEHExceptStmt
   finally_handler: multiplier.ast.SEHFinallyStmt
@@ -34386,7 +34371,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SEHTryStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SEHTryStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SEHTryStmt]:
     ...
 
   @overload
@@ -34414,46 +34399,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SEHTryStmt]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SEHTryStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SEHTryStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHTryStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SEHTryStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SEHTryStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHTryStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHTryStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHTryStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SEHTryStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SEHTryStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SEHTryStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHTryStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SEHTryStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SEHTryStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHTryStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SEHTryStmt]:
     ...
 
 class SEHLeaveStmt(multiplier.ast.Stmt):
@@ -34476,7 +34456,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SEHLeaveStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SEHLeaveStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SEHLeaveStmt]:
     ...
 
   @overload
@@ -34504,46 +34484,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SEHLeaveStm
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SEHLeaveStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SEHLeaveStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHLeaveStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SEHLeaveStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SEHLeaveStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHLeaveStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHLeaveStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHLeaveStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SEHLeaveStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SEHLeaveStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SEHLeaveStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHLeaveStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SEHLeaveStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SEHLeaveStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHLeaveStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SEHLeaveStmt]:
     ...
 
 class SEHFinallyStmt(multiplier.ast.Stmt):
@@ -34567,7 +34542,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SEHFinallyStmt
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SEHFinallyStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SEHFinallyStmt]:
     ...
 
   @overload
@@ -34595,46 +34570,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SEHFinallyS
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SEHFinallyStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SEHFinallyStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHFinallyStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SEHFinallyStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SEHFinallyStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHFinallyStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHFinallyStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHFinallyStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SEHFinallyStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SEHFinallyStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SEHFinallyStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHFinallyStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SEHFinallyStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SEHFinallyStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHFinallyStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SEHFinallyStmt]:
     ...
 
 class SEHExceptStmt(multiplier.ast.Stmt):
@@ -34659,7 +34629,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SEHExceptStmt]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SEHExceptStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SEHExceptStmt]:
     ...
 
   @overload
@@ -34687,46 +34657,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SEHExceptSt
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SEHExceptStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SEHExceptStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHExceptStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SEHExceptStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SEHExceptStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHExceptStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHExceptStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHExceptStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SEHExceptStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SEHExceptStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SEHExceptStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SEHExceptStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SEHExceptStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SEHExceptStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SEHExceptStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SEHExceptStmt]:
     ...
 
 class ReturnStmt(multiplier.ast.Stmt):
@@ -34751,7 +34716,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ReturnStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ReturnStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ReturnStmt]:
     ...
 
   @overload
@@ -34779,46 +34744,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ReturnStmt]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ReturnStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ReturnStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ReturnStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ReturnStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ReturnStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ReturnStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReturnStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ReturnStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ReturnStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ReturnStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ReturnStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ReturnStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ReturnStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ReturnStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ReturnStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ReturnStmt]:
     ...
 
 class ObjCForCollectionStmt(multiplier.ast.Stmt):
@@ -34845,7 +34805,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCForCollect
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCForCollectionStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCForCollectionStmt]:
     ...
 
   @overload
@@ -34873,46 +34833,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCForColl
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCForCollectionStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCForCollectionStmt]:
     ...
 
 class ObjCAutoreleasePoolStmt(multiplier.ast.Stmt):
@@ -34936,7 +34891,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCAutoreleas
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCAutoreleasePoolStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCAutoreleasePoolStmt]:
     ...
 
   @overload
@@ -34964,46 +34919,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCAutorel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCAutoreleasePoolStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAutoreleasePoolStmt]:
     ...
 
 class ObjCAtTryStmt(multiplier.ast.Stmt):
@@ -35030,7 +34980,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCAtTryStmt]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCAtTryStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCAtTryStmt]:
     ...
 
   @overload
@@ -35058,46 +35008,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCAtTrySt
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCAtTryStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCAtTryStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtTryStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtTryStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAtTryStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtTryStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtTryStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtTryStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCAtTryStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAtTryStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtTryStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtTryStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtTryStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtTryStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtTryStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtTryStmt]:
     ...
 
   def nth_catch_statement(self, n: int) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
@@ -35124,7 +35069,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCAtThrowStm
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCAtThrowStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCAtThrowStmt]:
     ...
 
   @overload
@@ -35152,46 +35097,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCAtThrow
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCAtThrowStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtThrowStmt]:
     ...
 
 class ObjCAtSynchronizedStmt(multiplier.ast.Stmt):
@@ -35216,7 +35156,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCAtSynchron
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCAtSynchronizedStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCAtSynchronizedStmt]:
     ...
 
   @overload
@@ -35244,46 +35184,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCAtSynch
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCAtSynchronizedStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtSynchronizedStmt]:
     ...
 
 class ObjCAtFinallyStmt(multiplier.ast.Stmt):
@@ -35307,7 +35242,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCAtFinallyS
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCAtFinallyStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCAtFinallyStmt]:
     ...
 
   @overload
@@ -35335,46 +35270,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCAtFinal
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCAtFinallyStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtFinallyStmt]:
     ...
 
 class ObjCAtCatchStmt(multiplier.ast.Stmt):
@@ -35401,7 +35331,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCAtCatchStm
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCAtCatchStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCAtCatchStmt]:
     ...
 
   @overload
@@ -35429,9 +35359,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCAtCatch
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCAtCatchStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
     ...
 
   @overload
@@ -35451,7 +35388,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
     ...
 
   @overload
@@ -35459,18 +35396,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAtCatchStmt]:
-    ...
-
 class OMPExecutableDirective(multiplier.ast.Stmt):
   associated_statement: multiplier.ast.Stmt
   innermost_captured_statement: multiplier.ast.CapturedStmt
@@ -35496,7 +35421,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPExecutableD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPExecutableDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPExecutableDirective]:
     ...
 
   @overload
@@ -35524,9 +35449,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPExecutab
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPExecutableDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPExecutableDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPExecutableDirective]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPExecutableDirective]:
     ...
 
   @overload
@@ -35546,7 +35474,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPExecutableDirect
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPExecutableDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPExecutableDirective]:
     ...
 
   @overload
@@ -35554,14 +35482,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPExecutableDirective]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPExecutableDirective]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPExecutableDirective]:
-    ...
-
 class OMPErrorDirective(multiplier.ast.OMPExecutableDirective):
 
   @overload
@@ -35581,7 +35501,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPErrorDirect
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPErrorDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPErrorDirective]:
     ...
 
   @overload
@@ -35609,46 +35529,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPErrorDir
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPErrorDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPErrorDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPErrorDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPErrorDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPErrorDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPErrorDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPErrorDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPErrorDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPErrorDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPErrorDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPErrorDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPErrorDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPErrorDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPErrorDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPErrorDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPErrorDirective]:
     ...
 
 class OMPDispatchDirective(multiplier.ast.OMPExecutableDirective):
@@ -35671,7 +35586,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDispatchDir
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDispatchDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDispatchDirective]:
     ...
 
   @overload
@@ -35699,46 +35614,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDispatch
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDispatchDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDispatchDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDispatchDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDispatchDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDispatchDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDispatchDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDispatchDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDispatchDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDispatchDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDispatchDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDispatchDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDispatchDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDispatchDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDispatchDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDispatchDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDispatchDirective]:
     ...
 
 class OMPDepobjDirective(multiplier.ast.OMPExecutableDirective):
@@ -35760,7 +35670,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDepobjDirec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDepobjDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDepobjDirective]:
     ...
 
   @overload
@@ -35788,46 +35698,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDepobjDi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDepobjDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDepobjDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDepobjDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDepobjDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDepobjDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDepobjDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDepobjDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDepobjDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDepobjDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDepobjDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDepobjDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDepobjDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDepobjDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDepobjDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDepobjDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDepobjDirective]:
     ...
 
 class OMPCriticalDirective(multiplier.ast.OMPExecutableDirective):
@@ -35849,7 +35754,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPCriticalDir
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPCriticalDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPCriticalDirective]:
     ...
 
   @overload
@@ -35877,46 +35782,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPCritical
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPCriticalDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPCriticalDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCriticalDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCriticalDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPCriticalDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCriticalDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCriticalDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCriticalDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPCriticalDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPCriticalDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCriticalDirective]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCriticalDirective]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCriticalDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCriticalDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCriticalDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCriticalDirective]:
     ...
 
 class OMPCancellationPointDirective(multiplier.ast.OMPExecutableDirective):
@@ -35938,7 +35838,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPCancellatio
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPCancellationPointDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPCancellationPointDirective]:
     ...
 
   @overload
@@ -35966,46 +35866,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPCancella
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPCancellationPointDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCancellationPointDirective]:
     ...
 
 class OMPCancelDirective(multiplier.ast.OMPExecutableDirective):
@@ -36027,7 +35922,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPCancelDirec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPCancelDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPCancelDirective]:
     ...
 
   @overload
@@ -36055,46 +35950,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPCancelDi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPCancelDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPCancelDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCancelDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCancelDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPCancelDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCancelDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCancelDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCancelDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPCancelDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPCancelDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCancelDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCancelDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCancelDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCancelDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCancelDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCancelDirective]:
     ...
 
 class OMPBarrierDirective(multiplier.ast.OMPExecutableDirective):
@@ -36116,7 +36006,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPBarrierDire
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPBarrierDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPBarrierDirective]:
     ...
 
   @overload
@@ -36144,46 +36034,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPBarrierD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPBarrierDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPBarrierDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPBarrierDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPBarrierDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPBarrierDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPBarrierDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPBarrierDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPBarrierDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPBarrierDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPBarrierDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPBarrierDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPBarrierDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPBarrierDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPBarrierDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPBarrierDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPBarrierDirective]:
     ...
 
 class OMPAtomicDirective(multiplier.ast.OMPExecutableDirective):
@@ -36215,7 +36100,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPAtomicDirec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPAtomicDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPAtomicDirective]:
     ...
 
   @overload
@@ -36243,46 +36128,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPAtomicDi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPAtomicDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPAtomicDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPAtomicDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPAtomicDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPAtomicDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPAtomicDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPAtomicDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPAtomicDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPAtomicDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPAtomicDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPAtomicDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPAtomicDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPAtomicDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPAtomicDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPAtomicDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPAtomicDirective]:
     ...
 
 class OMPTeamsDirective(multiplier.ast.OMPExecutableDirective):
@@ -36304,7 +36184,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTeamsDirect
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTeamsDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTeamsDirective]:
     ...
 
   @overload
@@ -36332,46 +36212,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTeamsDir
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTeamsDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTeamsDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTeamsDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDirective]:
     ...
 
 class OMPTaskyieldDirective(multiplier.ast.OMPExecutableDirective):
@@ -36393,7 +36268,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTaskyieldDi
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTaskyieldDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTaskyieldDirective]:
     ...
 
   @overload
@@ -36421,46 +36296,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTaskyiel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTaskyieldDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskyieldDirective]:
     ...
 
 class OMPTaskwaitDirective(multiplier.ast.OMPExecutableDirective):
@@ -36482,7 +36352,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTaskwaitDir
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTaskwaitDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTaskwaitDirective]:
     ...
 
   @overload
@@ -36510,46 +36380,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTaskwait
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTaskwaitDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskwaitDirective]:
     ...
 
 class OMPTaskgroupDirective(multiplier.ast.OMPExecutableDirective):
@@ -36572,7 +36437,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTaskgroupDi
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTaskgroupDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTaskgroupDirective]:
     ...
 
   @overload
@@ -36600,46 +36465,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTaskgrou
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTaskgroupDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskgroupDirective]:
     ...
 
 class OMPTaskDirective(multiplier.ast.OMPExecutableDirective):
@@ -36662,7 +36522,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTaskDirecti
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTaskDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTaskDirective]:
     ...
 
   @overload
@@ -36690,46 +36550,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTaskDire
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTaskDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTaskDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTaskDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskDirective]:
     ...
 
 class OMPTargetUpdateDirective(multiplier.ast.OMPExecutableDirective):
@@ -36751,7 +36606,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetUpdat
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetUpdateDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetUpdateDirective]:
     ...
 
   @overload
@@ -36779,46 +36634,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetUp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetUpdateDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetUpdateDirective]:
     ...
 
 class OMPTargetTeamsDirective(multiplier.ast.OMPExecutableDirective):
@@ -36840,7 +36690,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetTeams
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetTeamsDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetTeamsDirective]:
     ...
 
   @overload
@@ -36868,46 +36718,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetTe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetTeamsDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDirective]:
     ...
 
 class OMPTargetParallelDirective(multiplier.ast.OMPExecutableDirective):
@@ -36931,7 +36776,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetParal
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetParallelDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetParallelDirective]:
     ...
 
   @overload
@@ -36959,46 +36804,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetPa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetParallelDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetParallelDirective]:
     ...
 
 class OMPTargetExitDataDirective(multiplier.ast.OMPExecutableDirective):
@@ -37020,7 +36860,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetExitD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetExitDataDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetExitDataDirective]:
     ...
 
   @overload
@@ -37048,46 +36888,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetEx
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetExitDataDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetExitDataDirective]:
     ...
 
 class OMPTargetEnterDataDirective(multiplier.ast.OMPExecutableDirective):
@@ -37109,7 +36944,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetEnter
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetEnterDataDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetEnterDataDirective]:
     ...
 
   @overload
@@ -37137,46 +36972,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetEn
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetEnterDataDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetEnterDataDirective]:
     ...
 
 class OMPTargetDirective(multiplier.ast.OMPExecutableDirective):
@@ -37198,7 +37028,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetDirec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetDirective]:
     ...
 
   @overload
@@ -37226,46 +37056,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetDi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetDirective]:
     ...
 
 class OMPTargetDataDirective(multiplier.ast.OMPExecutableDirective):
@@ -37287,7 +37112,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetDataD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetDataDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetDataDirective]:
     ...
 
   @overload
@@ -37315,46 +37140,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetDa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetDataDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetDataDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetDataDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetDataDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetDataDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetDataDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetDataDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetDataDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetDataDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetDataDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetDataDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetDataDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetDataDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetDataDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetDataDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetDataDirective]:
     ...
 
 class OMPSingleDirective(multiplier.ast.OMPExecutableDirective):
@@ -37376,7 +37196,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPSingleDirec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPSingleDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPSingleDirective]:
     ...
 
   @overload
@@ -37404,46 +37224,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPSingleDi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPSingleDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPSingleDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSingleDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPSingleDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPSingleDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSingleDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSingleDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSingleDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPSingleDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPSingleDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPSingleDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSingleDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPSingleDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPSingleDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSingleDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPSingleDirective]:
     ...
 
 class OMPSectionsDirective(multiplier.ast.OMPExecutableDirective):
@@ -37467,7 +37282,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPSectionsDir
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPSectionsDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPSectionsDirective]:
     ...
 
   @overload
@@ -37495,46 +37310,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPSections
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPSectionsDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPSectionsDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSectionsDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPSectionsDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPSectionsDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSectionsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSectionsDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSectionsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPSectionsDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPSectionsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPSectionsDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSectionsDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPSectionsDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPSectionsDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSectionsDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPSectionsDirective]:
     ...
 
 class OMPSectionDirective(multiplier.ast.OMPExecutableDirective):
@@ -37557,7 +37367,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPSectionDire
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPSectionDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPSectionDirective]:
     ...
 
   @overload
@@ -37585,46 +37395,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPSectionD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPSectionDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPSectionDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSectionDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPSectionDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPSectionDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSectionDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSectionDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSectionDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPSectionDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPSectionDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPSectionDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSectionDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPSectionDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPSectionDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSectionDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPSectionDirective]:
     ...
 
 class OMPScopeDirective(multiplier.ast.OMPExecutableDirective):
@@ -37646,7 +37451,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPScopeDirect
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPScopeDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPScopeDirective]:
     ...
 
   @overload
@@ -37674,46 +37479,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPScopeDir
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPScopeDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPScopeDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPScopeDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPScopeDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPScopeDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPScopeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPScopeDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPScopeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPScopeDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPScopeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPScopeDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPScopeDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPScopeDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPScopeDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPScopeDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPScopeDirective]:
     ...
 
 class OMPScanDirective(multiplier.ast.OMPExecutableDirective):
@@ -37735,7 +37535,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPScanDirecti
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPScanDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPScanDirective]:
     ...
 
   @overload
@@ -37763,46 +37563,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPScanDire
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPScanDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPScanDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPScanDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPScanDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPScanDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPScanDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPScanDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPScanDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPScanDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPScanDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPScanDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPScanDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPScanDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPScanDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPScanDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPScanDirective]:
     ...
 
 class OMPParallelSectionsDirective(multiplier.ast.OMPExecutableDirective):
@@ -37826,7 +37621,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelSec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelSectionsDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelSectionsDirective]:
     ...
 
   @overload
@@ -37854,46 +37649,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelSectionsDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelSectionsDirective]:
     ...
 
 class OMPParallelMasterDirective(multiplier.ast.OMPExecutableDirective):
@@ -37916,7 +37706,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelMas
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelMasterDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelMasterDirective]:
     ...
 
   @overload
@@ -37944,46 +37734,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelMasterDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMasterDirective]:
     ...
 
 class OMPParallelMaskedDirective(multiplier.ast.OMPExecutableDirective):
@@ -38006,7 +37791,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelMas
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelMaskedDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelMaskedDirective]:
     ...
 
   @overload
@@ -38034,46 +37819,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelMaskedDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMaskedDirective]:
     ...
 
 class OMPParallelDirective(multiplier.ast.OMPExecutableDirective):
@@ -38097,7 +37877,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelDir
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelDirective]:
     ...
 
   @overload
@@ -38125,46 +37905,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelDirective]:
     ...
 
 class OMPOrderedDirective(multiplier.ast.OMPExecutableDirective):
@@ -38186,7 +37961,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPOrderedDire
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPOrderedDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPOrderedDirective]:
     ...
 
   @overload
@@ -38214,46 +37989,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPOrderedD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPOrderedDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPOrderedDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPOrderedDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPOrderedDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPOrderedDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPOrderedDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPOrderedDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPOrderedDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPOrderedDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPOrderedDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPOrderedDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPOrderedDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPOrderedDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPOrderedDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPOrderedDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPOrderedDirective]:
     ...
 
 class OMPMetaDirective(multiplier.ast.OMPExecutableDirective):
@@ -38276,7 +38046,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPMetaDirecti
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPMetaDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPMetaDirective]:
     ...
 
   @overload
@@ -38304,46 +38074,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPMetaDire
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPMetaDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPMetaDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMetaDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMetaDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMetaDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMetaDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMetaDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMetaDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPMetaDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMetaDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMetaDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMetaDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMetaDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMetaDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMetaDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMetaDirective]:
     ...
 
 class OMPMasterDirective(multiplier.ast.OMPExecutableDirective):
@@ -38365,7 +38130,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPMasterDirec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPMasterDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPMasterDirective]:
     ...
 
   @overload
@@ -38393,46 +38158,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPMasterDi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPMasterDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPMasterDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMasterDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMasterDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMasterDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPMasterDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMasterDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMasterDirective]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMasterDirective]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMasterDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMasterDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMasterDirective]:
     ...
 
 class OMPMaskedDirective(multiplier.ast.OMPExecutableDirective):
@@ -38454,7 +38214,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPMaskedDirec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPMaskedDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPMaskedDirective]:
     ...
 
   @overload
@@ -38482,46 +38242,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPMaskedDi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPMaskedDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPMaskedDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMaskedDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMaskedDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMaskedDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPMaskedDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMaskedDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMaskedDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMaskedDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMaskedDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMaskedDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMaskedDirective]:
     ...
 
 class OMPLoopBasedDirective(multiplier.ast.OMPExecutableDirective):
@@ -38544,7 +38299,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPLoopBasedDi
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPLoopBasedDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPLoopBasedDirective]:
     ...
 
   @overload
@@ -38572,9 +38327,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPLoopBase
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPLoopBasedDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPLoopBasedDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPLoopBasedDirective]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPLoopBasedDirective]:
     ...
 
   @overload
@@ -38594,7 +38352,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPLoopBasedDirecti
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPLoopBasedDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPLoopBasedDirective]:
     ...
 
   @overload
@@ -38602,14 +38360,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPLoopBasedDirective]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPLoopBasedDirective]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPLoopBasedDirective]:
-    ...
-
 class OMPLoopTransformationDirective(multiplier.ast.OMPLoopBasedDirective):
   pre_initializers: multiplier.ast.Stmt
   transformed_statement: multiplier.ast.Stmt
@@ -38631,7 +38381,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPLoopTransfo
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPLoopTransformationDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPLoopTransformationDirective]:
     ...
 
   @overload
@@ -38659,9 +38409,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPLoopTran
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPLoopTransformationDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPLoopTransformationDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPLoopTransformationDirective]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPLoopTransformationDirective]:
     ...
 
   @overload
@@ -38681,7 +38434,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPLoopTransformati
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPLoopTransformationDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPLoopTransformationDirective]:
     ...
 
   @overload
@@ -38689,14 +38442,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPLoopTransformationDirective]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPLoopTransformationDirective]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPLoopTransformationDirective]:
-    ...
-
 class OMPUnrollDirective(multiplier.ast.OMPLoopTransformationDirective):
 
   @overload
@@ -38716,7 +38461,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPUnrollDirec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPUnrollDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPUnrollDirective]:
     ...
 
   @overload
@@ -38744,9 +38489,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPUnrollDi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPUnrollDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPUnrollDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPUnrollDirective]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPUnrollDirective]:
     ...
 
   @overload
@@ -38766,7 +38518,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPUnrollDirective]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPUnrollDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPUnrollDirective]:
     ...
 
   @overload
@@ -38774,18 +38526,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPUnrollDirective]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPUnrollDirective]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPUnrollDirective]:
-    ...
-
 class OMPTileDirective(multiplier.ast.OMPLoopTransformationDirective):
 
   @overload
@@ -38805,7 +38545,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTileDirecti
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTileDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTileDirective]:
     ...
 
   @overload
@@ -38833,46 +38573,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTileDire
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTileDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTileDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTileDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTileDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTileDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTileDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTileDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTileDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTileDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTileDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTileDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTileDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTileDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTileDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTileDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTileDirective]:
     ...
 
 class OMPLoopDirective(multiplier.ast.OMPLoopBasedDirective):
@@ -38939,7 +38674,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPLoopDirecti
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPLoopDirective]:
     ...
 
   @overload
@@ -38967,9 +38702,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPLoopDire
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPLoopDirective]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPLoopDirective]:
     ...
 
   @overload
@@ -38989,7 +38727,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPLoopDirective]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPLoopDirective]:
     ...
 
   @overload
@@ -38997,14 +38735,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPLoopDirective]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPLoopDirective]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPLoopDirective]:
-    ...
-
   def nth_counter(self, n: int) -> Optional[multiplier.ast.Expr]:
     ...
 
@@ -39048,7 +38778,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPGenericLoop
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPGenericLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPGenericLoopDirective]:
     ...
 
   @overload
@@ -39076,46 +38806,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPGenericL
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPGenericLoopDirective]:
     ...
 
 class OMPForSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -39137,7 +38862,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPForSimdDire
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPForSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPForSimdDirective]:
     ...
 
   @overload
@@ -39165,46 +38890,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPForSimdD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPForSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPForSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPForSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPForSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPForSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPForSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPForSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPForSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPForSimdDirective]:
     ...
 
 class OMPForDirective(multiplier.ast.OMPLoopDirective):
@@ -39228,7 +38948,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPForDirectiv
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPForDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPForDirective]:
     ...
 
   @overload
@@ -39256,46 +38976,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPForDirec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPForDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPForDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPForDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPForDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPForDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPForDirective]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPForDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPForDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPForDirective]:
     ...
 
 class OMPDistributeSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -39317,7 +39032,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDistributeS
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDistributeSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDistributeSimdDirective]:
     ...
 
   @overload
@@ -39345,46 +39060,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDistribu
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDistributeSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDistributeSimdDirective]:
     ...
 
 class OMPDistributeParallelForSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -39406,7 +39116,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDistributeP
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDistributeParallelForSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDistributeParallelForSimdDirective]:
     ...
 
   @overload
@@ -39434,46 +39144,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDistribu
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDistributeParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDistributeParallelForSimdDirective]:
     ...
 
 class OMPDistributeParallelForDirective(multiplier.ast.OMPLoopDirective):
@@ -39497,7 +39202,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDistributeP
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDistributeParallelForDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDistributeParallelForDirective]:
     ...
 
   @overload
@@ -39525,46 +39230,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDistribu
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDistributeParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDistributeParallelForDirective]:
     ...
 
 class OMPDistributeDirective(multiplier.ast.OMPLoopDirective):
@@ -39586,7 +39286,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDistributeD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDistributeDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDistributeDirective]:
     ...
 
   @overload
@@ -39614,46 +39314,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDistribu
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDistributeDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDistributeDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDistributeDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDistributeDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDistributeDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPDistributeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDistributeDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDistributeDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDistributeDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDistributeDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPDistributeDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDistributeDirective]:
     ...
 
 class OMPTeamsGenericLoopDirective(multiplier.ast.OMPLoopDirective):
@@ -39675,7 +39370,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTeamsGeneri
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTeamsGenericLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTeamsGenericLoopDirective]:
     ...
 
   @overload
@@ -39703,46 +39398,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTeamsGen
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTeamsGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsGenericLoopDirective]:
     ...
 
 class OMPTeamsDistributeSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -39764,7 +39454,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTeamsDistri
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTeamsDistributeSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTeamsDistributeSimdDirective]:
     ...
 
   @overload
@@ -39792,46 +39482,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTeamsDis
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTeamsDistributeSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDistributeSimdDirective]:
     ...
 
 class OMPTeamsDistributeParallelForSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -39853,7 +39538,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTeamsDistri
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
     ...
 
   @overload
@@ -39881,46 +39566,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTeamsDis
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForSimdDirective]:
     ...
 
 class OMPTeamsDistributeParallelForDirective(multiplier.ast.OMPLoopDirective):
@@ -39944,7 +39624,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTeamsDistri
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTeamsDistributeParallelForDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
     ...
 
   @overload
@@ -39972,46 +39652,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTeamsDis
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDistributeParallelForDirective]:
     ...
 
 class OMPTeamsDistributeDirective(multiplier.ast.OMPLoopDirective):
@@ -40033,7 +39708,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTeamsDistri
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTeamsDistributeDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTeamsDistributeDirective]:
     ...
 
   @overload
@@ -40061,46 +39736,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTeamsDis
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTeamsDistributeDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTeamsDistributeDirective]:
     ...
 
 class OMPTaskLoopSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -40122,7 +39792,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTaskLoopSim
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTaskLoopSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTaskLoopSimdDirective]:
     ...
 
   @overload
@@ -40150,46 +39820,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTaskLoop
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskLoopSimdDirective]:
     ...
 
 class OMPTaskLoopDirective(multiplier.ast.OMPLoopDirective):
@@ -40212,7 +39877,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTaskLoopDir
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTaskLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTaskLoopDirective]:
     ...
 
   @overload
@@ -40240,46 +39905,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTaskLoop
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTaskLoopDirective]:
     ...
 
 class OMPTargetTeamsGenericLoopDirective(multiplier.ast.OMPLoopDirective):
@@ -40301,7 +39961,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetTeams
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetTeamsGenericLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
     ...
 
   @overload
@@ -40329,46 +39989,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetTe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsGenericLoopDirective]:
     ...
 
 class OMPTargetTeamsDistributeSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -40390,7 +40045,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetTeams
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetTeamsDistributeSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
     ...
 
   @overload
@@ -40418,46 +40073,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetTe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDistributeSimdDirective]:
     ...
 
 class OMPTargetTeamsDistributeParallelForSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -40479,7 +40129,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetTeams
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
     ...
 
   @overload
@@ -40507,46 +40157,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetTe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForSimdDirective]:
     ...
 
 class OMPTargetTeamsDistributeParallelForDirective(multiplier.ast.OMPLoopDirective):
@@ -40570,7 +40215,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetTeams
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
     ...
 
   @overload
@@ -40598,46 +40243,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetTe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDistributeParallelForDirective]:
     ...
 
 class OMPTargetTeamsDistributeDirective(multiplier.ast.OMPLoopDirective):
@@ -40659,7 +40299,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetTeams
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetTeamsDistributeDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetTeamsDistributeDirective]:
     ...
 
   @overload
@@ -40687,46 +40327,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetTe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetTeamsDistributeDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetTeamsDistributeDirective]:
     ...
 
 class OMPTargetSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -40748,7 +40383,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetSimdD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetSimdDirective]:
     ...
 
   @overload
@@ -40776,46 +40411,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetSi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetSimdDirective]:
     ...
 
 class OMPTargetParallelGenericLoopDirective(multiplier.ast.OMPLoopDirective):
@@ -40837,7 +40467,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetParal
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetParallelGenericLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
     ...
 
   @overload
@@ -40865,46 +40495,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetPa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetParallelGenericLoopDirective]:
     ...
 
 class OMPTargetParallelForSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -40926,7 +40551,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetParal
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetParallelForSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetParallelForSimdDirective]:
     ...
 
   @overload
@@ -40954,46 +40579,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetPa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetParallelForSimdDirective]:
     ...
 
 class OMPTargetParallelForDirective(multiplier.ast.OMPLoopDirective):
@@ -41017,7 +40637,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPTargetParal
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPTargetParallelForDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPTargetParallelForDirective]:
     ...
 
   @overload
@@ -41045,46 +40665,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPTargetPa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPTargetParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPTargetParallelForDirective]:
     ...
 
 class OMPSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -41106,7 +40721,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPSimdDirecti
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPSimdDirective]:
     ...
 
   @overload
@@ -41134,46 +40749,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPSimdDire
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPSimdDirective]:
     ...
 
 class OMPParallelMasterTaskLoopSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -41195,7 +40805,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelMas
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
     ...
 
   @overload
@@ -41223,46 +40833,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopSimdDirective]:
     ...
 
 class OMPParallelMasterTaskLoopDirective(multiplier.ast.OMPLoopDirective):
@@ -41285,7 +40890,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelMas
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelMasterTaskLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
     ...
 
   @overload
@@ -41313,46 +40918,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMasterTaskLoopDirective]:
     ...
 
 class OMPParallelMaskedTaskLoopSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -41374,7 +40974,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelMas
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
     ...
 
   @overload
@@ -41402,46 +41002,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopSimdDirective]:
     ...
 
 class OMPParallelMaskedTaskLoopDirective(multiplier.ast.OMPLoopDirective):
@@ -41464,7 +41059,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelMas
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelMaskedTaskLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
     ...
 
   @overload
@@ -41492,46 +41087,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelMaskedTaskLoopDirective]:
     ...
 
 class OMPParallelGenericLoopDirective(multiplier.ast.OMPLoopDirective):
@@ -41553,7 +41143,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelGen
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelGenericLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelGenericLoopDirective]:
     ...
 
   @overload
@@ -41581,46 +41171,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelGenericLoopDirective]:
     ...
 
 class OMPParallelForSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -41642,7 +41227,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelFor
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelForSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelForSimdDirective]:
     ...
 
   @overload
@@ -41670,46 +41255,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelForSimdDirective]:
     ...
 
 class OMPParallelForDirective(multiplier.ast.OMPLoopDirective):
@@ -41733,7 +41313,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPParallelFor
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPParallelForDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPParallelForDirective]:
     ...
 
   @overload
@@ -41761,46 +41341,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPParallel
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPParallelForDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelForDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelForDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelForDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelForDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPParallelForDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPParallelForDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelForDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPParallelForDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPParallelForDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPParallelForDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPParallelForDirective]:
     ...
 
 class OMPMasterTaskLoopSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -41822,7 +41397,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPMasterTaskL
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPMasterTaskLoopSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
     ...
 
   @overload
@@ -41850,46 +41425,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPMasterTa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMasterTaskLoopSimdDirective]:
     ...
 
 class OMPMasterTaskLoopDirective(multiplier.ast.OMPLoopDirective):
@@ -41912,7 +41482,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPMasterTaskL
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPMasterTaskLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPMasterTaskLoopDirective]:
     ...
 
   @overload
@@ -41940,46 +41510,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPMasterTa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPMasterTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMasterTaskLoopDirective]:
     ...
 
 class OMPMaskedTaskLoopSimdDirective(multiplier.ast.OMPLoopDirective):
@@ -42001,7 +41566,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPMaskedTaskL
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPMaskedTaskLoopSimdDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
     ...
 
   @overload
@@ -42029,46 +41594,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPMaskedTa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMaskedTaskLoopSimdDirective]:
     ...
 
 class OMPMaskedTaskLoopDirective(multiplier.ast.OMPLoopDirective):
@@ -42091,7 +41651,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPMaskedTaskL
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPMaskedTaskLoopDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPMaskedTaskLoopDirective]:
     ...
 
   @overload
@@ -42119,46 +41679,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPMaskedTa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPMaskedTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPMaskedTaskLoopDirective]:
     ...
 
 class OMPInteropDirective(multiplier.ast.OMPExecutableDirective):
@@ -42180,7 +41735,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPInteropDire
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPInteropDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPInteropDirective]:
     ...
 
   @overload
@@ -42208,46 +41763,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPInteropD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPInteropDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPInteropDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPInteropDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPInteropDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPInteropDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPInteropDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPInteropDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPInteropDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPInteropDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPInteropDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPInteropDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPInteropDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPInteropDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPInteropDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPInteropDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPInteropDirective]:
     ...
 
 class OMPFlushDirective(multiplier.ast.OMPExecutableDirective):
@@ -42269,7 +41819,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPFlushDirect
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPFlushDirective, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPFlushDirective]:
     ...
 
   @overload
@@ -42297,46 +41847,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPFlushDir
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPFlushDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPFlushDirective]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPFlushDirective]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPFlushDirective]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPFlushDirective]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPFlushDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPFlushDirective]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPFlushDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPFlushDirective]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPFlushDirective]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPFlushDirective]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPFlushDirective]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPFlushDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPFlushDirective]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPFlushDirective]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPFlushDirective]:
     ...
 
 class OMPCanonicalLoop(multiplier.ast.Stmt):
@@ -42362,7 +41907,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPCanonicalLo
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPCanonicalLoop, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPCanonicalLoop]:
     ...
 
   @overload
@@ -42390,46 +41935,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPCanonica
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPCanonicalLoop]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPCanonicalLoop]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCanonicalLoop]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCanonicalLoop]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPCanonicalLoop]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCanonicalLoop]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCanonicalLoop]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCanonicalLoop]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPCanonicalLoop]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPCanonicalLoop]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCanonicalLoop]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCanonicalLoop]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCanonicalLoop]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCanonicalLoop]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPCanonicalLoop]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCanonicalLoop]:
     ...
 
 class NullStmt(multiplier.ast.Stmt):
@@ -42453,7 +41993,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.NullStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.NullStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.NullStmt]:
     ...
 
   @overload
@@ -42481,46 +42021,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.NullStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.NullStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.NullStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.NullStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NullStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.NullStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.NullStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NullStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.NullStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NullStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.NullStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NullStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NullStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NullStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NullStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.NullStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NullStmt]:
     ...
 
 class MSDependentExistsStmt(multiplier.ast.Stmt):
@@ -42546,7 +42081,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.MSDependentExi
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.MSDependentExistsStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.MSDependentExistsStmt]:
     ...
 
   @overload
@@ -42574,46 +42109,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.MSDependent
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.MSDependentExistsStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.MSDependentExistsStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSDependentExistsStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSDependentExistsStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MSDependentExistsStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSDependentExistsStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSDependentExistsStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSDependentExistsStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSDependentExistsStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MSDependentExistsStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSDependentExistsStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSDependentExistsStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSDependentExistsStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSDependentExistsStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSDependentExistsStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSDependentExistsStmt]:
     ...
 
 class IndirectGotoStmt(multiplier.ast.Stmt):
@@ -42639,7 +42169,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.IndirectGotoSt
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.IndirectGotoStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.IndirectGotoStmt]:
     ...
 
   @overload
@@ -42667,46 +42197,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.IndirectGot
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.IndirectGotoStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.IndirectGotoStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IndirectGotoStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.IndirectGotoStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.IndirectGotoStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IndirectGotoStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IndirectGotoStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IndirectGotoStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IndirectGotoStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.IndirectGotoStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.IndirectGotoStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IndirectGotoStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.IndirectGotoStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IndirectGotoStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IndirectGotoStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.IndirectGotoStmt]:
     ...
 
 class IfStmt(multiplier.ast.Stmt):
@@ -42748,7 +42273,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.IfStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.IfStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.IfStmt]:
     ...
 
   @overload
@@ -42776,46 +42301,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.IfStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.IfStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.IfStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IfStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.IfStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.IfStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IfStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IfStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IfStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IfStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.IfStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.IfStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IfStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.IfStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IfStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IfStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.IfStmt]:
     ...
 
 class GotoStmt(multiplier.ast.Stmt):
@@ -42840,7 +42360,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.GotoStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.GotoStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.GotoStmt]:
     ...
 
   @overload
@@ -42868,46 +42388,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.GotoStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.GotoStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.GotoStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GotoStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.GotoStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.GotoStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GotoStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GotoStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GotoStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.GotoStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.GotoStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.GotoStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GotoStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.GotoStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GotoStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GotoStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.GotoStmt]:
     ...
 
 class ForStmt(multiplier.ast.Stmt):
@@ -42938,7 +42453,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ForStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ForStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ForStmt]:
     ...
 
   @overload
@@ -42966,46 +42481,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ForStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ForStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ForStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ForStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ForStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ForStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ForStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ForStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ForStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ForStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ForStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ForStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ForStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ForStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ForStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ForStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ForStmt]:
     ...
 
 class DoStmt(multiplier.ast.Stmt):
@@ -43032,7 +42542,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DoStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DoStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DoStmt]:
     ...
 
   @overload
@@ -43060,46 +42570,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.DoStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DoStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DoStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DoStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DoStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DoStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DoStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DoStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DoStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DoStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DoStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DoStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DoStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DoStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DoStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DoStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DoStmt]:
     ...
 
 class DeclStmt(multiplier.ast.Stmt):
@@ -43125,7 +42630,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DeclStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DeclStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DeclStmt]:
     ...
 
   @overload
@@ -43153,46 +42658,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.DeclStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DeclStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DeclStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DeclStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DeclStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DeclStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DeclStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DeclStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DeclStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DeclStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DeclStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DeclStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeclStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DeclStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DeclStmt]:
     ...
 
   def nth_declaration(self, n: int) -> Optional[multiplier.ast.Decl]:
@@ -43235,7 +42735,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CoroutineBodyS
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CoroutineBodyStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CoroutineBodyStmt]:
     ...
 
   @overload
@@ -43263,46 +42763,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CoroutineBo
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CoroutineBodyStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CoroutineBodyStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoroutineBodyStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoroutineBodyStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CoroutineBodyStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoroutineBodyStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroutineBodyStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoroutineBodyStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoroutineBodyStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CoroutineBodyStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CoroutineBodyStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroutineBodyStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoroutineBodyStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroutineBodyStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoroutineBodyStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CoroutineBodyStmt]:
     ...
 
   def nth_parameter_move(self, n: int) -> Optional[multiplier.ast.Stmt]:
@@ -43331,7 +42826,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CoreturnStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CoreturnStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CoreturnStmt]:
     ...
 
   @overload
@@ -43359,46 +42854,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CoreturnStm
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CoreturnStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CoreturnStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoreturnStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoreturnStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CoreturnStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoreturnStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoreturnStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoreturnStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoreturnStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CoreturnStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CoreturnStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoreturnStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoreturnStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoreturnStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoreturnStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CoreturnStmt]:
     ...
 
 class ContinueStmt(multiplier.ast.Stmt):
@@ -43421,7 +42911,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ContinueStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ContinueStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ContinueStmt]:
     ...
 
   @overload
@@ -43449,46 +42939,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ContinueStm
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ContinueStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ContinueStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ContinueStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ContinueStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ContinueStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ContinueStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ContinueStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ContinueStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ContinueStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ContinueStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ContinueStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ContinueStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ContinueStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ContinueStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ContinueStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ContinueStmt]:
     ...
 
 class CompoundStmt(multiplier.ast.Stmt):
@@ -43515,7 +43000,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CompoundStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CompoundStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CompoundStmt]:
     ...
 
   @overload
@@ -43543,46 +43028,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CompoundStm
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CompoundStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CompoundStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CompoundStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CompoundStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CompoundStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CompoundStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CompoundStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CompoundStmt]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CompoundStmt]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CompoundStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CompoundStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CompoundStmt]:
     ...
 
 class CapturedStmt(multiplier.ast.Stmt):
@@ -43608,7 +43088,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CapturedStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CapturedStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CapturedStmt]:
     ...
 
   @overload
@@ -43636,46 +43116,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CapturedStm
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CapturedStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CapturedStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CapturedStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CapturedStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CapturedStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CapturedStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapturedStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CapturedStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CapturedStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CapturedStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CapturedStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapturedStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CapturedStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CapturedStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CapturedStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CapturedStmt]:
     ...
 
 class CXXTryStmt(multiplier.ast.Stmt):
@@ -43701,7 +43176,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXTryStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXTryStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXTryStmt]:
     ...
 
   @overload
@@ -43729,46 +43204,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXTryStmt]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXTryStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXTryStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTryStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXTryStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXTryStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTryStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXTryStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTryStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXTryStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXTryStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXTryStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXTryStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXTryStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXTryStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTryStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXTryStmt]:
     ...
 
   def nth_handler(self, n: int) -> Optional[multiplier.ast.CXXCatchStmt]:
@@ -43807,7 +43277,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXForRangeStm
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXForRangeStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXForRangeStmt]:
     ...
 
   @overload
@@ -43835,46 +43305,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXForRange
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXForRangeStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXForRangeStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXForRangeStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXForRangeStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXForRangeStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXForRangeStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXForRangeStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXForRangeStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXForRangeStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXForRangeStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXForRangeStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXForRangeStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXForRangeStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXForRangeStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXForRangeStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXForRangeStmt]:
     ...
 
 class CXXCatchStmt(multiplier.ast.Stmt):
@@ -43900,7 +43365,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXCatchStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXCatchStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXCatchStmt]:
     ...
 
   @overload
@@ -43928,46 +43393,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXCatchStm
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXCatchStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXCatchStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXCatchStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXCatchStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXCatchStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXCatchStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXCatchStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXCatchStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXCatchStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXCatchStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXCatchStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXCatchStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXCatchStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXCatchStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXCatchStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXCatchStmt]:
     ...
 
 class BreakStmt(multiplier.ast.Stmt):
@@ -43990,7 +43450,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.BreakStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.BreakStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.BreakStmt]:
     ...
 
   @overload
@@ -44018,46 +43478,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.BreakStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.BreakStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.BreakStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BreakStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BreakStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BreakStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BreakStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BreakStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BreakStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BreakStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BreakStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BreakStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BreakStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BreakStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BreakStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BreakStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BreakStmt]:
     ...
 
 class AsmStmt(multiplier.ast.Stmt):
@@ -44094,7 +43549,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.AsmStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.AsmStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.AsmStmt]:
     ...
 
   @overload
@@ -44122,9 +43577,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.AsmStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.AsmStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.AsmStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AsmStmt]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AsmStmt]:
     ...
 
   @overload
@@ -44144,7 +43602,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AsmStmt]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AsmStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AsmStmt]:
     ...
 
   @overload
@@ -44152,14 +43610,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AsmStmt]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AsmStmt]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AsmStmt]:
-    ...
-
   def nth_input(self, n: int) -> Optional[multiplier.ast.Expr]:
     ...
 
@@ -44197,7 +43647,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.MSAsmStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.MSAsmStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.MSAsmStmt]:
     ...
 
   @overload
@@ -44225,46 +43675,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.MSAsmStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.MSAsmStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.MSAsmStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSAsmStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSAsmStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MSAsmStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSAsmStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSAsmStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSAsmStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSAsmStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MSAsmStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSAsmStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSAsmStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSAsmStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSAsmStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSAsmStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSAsmStmt]:
     ...
 
   def nth_all_expression(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -44305,7 +43750,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.GCCAsmStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.GCCAsmStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.GCCAsmStmt]:
     ...
 
   @overload
@@ -44333,46 +43778,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.GCCAsmStmt]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.GCCAsmStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.GCCAsmStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GCCAsmStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.GCCAsmStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.GCCAsmStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GCCAsmStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GCCAsmStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GCCAsmStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.GCCAsmStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.GCCAsmStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.GCCAsmStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GCCAsmStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.GCCAsmStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GCCAsmStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GCCAsmStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.GCCAsmStmt]:
     ...
 
   def nth_label(self, n: int) -> Optional[multiplier.ast.AddrLabelExpr]:
@@ -44417,7 +43857,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.WhileStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.WhileStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.WhileStmt]:
     ...
 
   @overload
@@ -44445,9 +43885,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.WhileStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.WhileStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.WhileStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.WhileStmt]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.WhileStmt]:
     ...
 
   @overload
@@ -44467,7 +43914,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.WhileStmt]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.WhileStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.WhileStmt]:
     ...
 
   @overload
@@ -44475,18 +43922,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.WhileStmt]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.WhileStmt]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.WhileStmt]:
-    ...
-
 class ValueStmt(multiplier.ast.Stmt):
   expression_statement: Optional[multiplier.ast.Expr]
 
@@ -44507,7 +43942,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ValueStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ValueStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ValueStmt]:
     ...
 
   @overload
@@ -44535,9 +43970,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ValueStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ValueStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ValueStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ValueStmt]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ValueStmt]:
     ...
 
   @overload
@@ -44557,7 +43995,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ValueStmt]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ValueStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ValueStmt]:
     ...
 
   @overload
@@ -44565,14 +44003,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ValueStmt]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ValueStmt]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ValueStmt]:
-    ...
-
 class LabelStmt(multiplier.ast.ValueStmt):
   declaration: multiplier.ast.LabelDecl
   identifier_token: multiplier.frontend.Token
@@ -44597,7 +44027,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.LabelStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.LabelStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.LabelStmt]:
     ...
 
   @overload
@@ -44625,46 +44055,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.LabelStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.LabelStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.LabelStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.LabelStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LabelStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.LabelStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.LabelStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LabelStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.LabelStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LabelStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.LabelStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LabelStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LabelStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LabelStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LabelStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.LabelStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LabelStmt]:
     ...
 
 class Expr(multiplier.ast.ValueStmt):
@@ -44725,7 +44150,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.Expr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.Expr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.Expr]:
     ...
 
   @overload
@@ -44753,9 +44178,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.Expr]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.Expr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.Expr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.Expr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.Expr]:
     ...
 
   @overload
@@ -44775,7 +44203,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Expr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.Expr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Expr]:
     ...
 
   @overload
@@ -44783,14 +44211,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.Expr]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.Expr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.Expr]:
-    ...
-
 class DesignatedInitUpdateExpr(multiplier.ast.Expr):
   base: multiplier.ast.Expr
   updater: multiplier.ast.InitListExpr
@@ -44812,7 +44232,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DesignatedInit
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DesignatedInitUpdateExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DesignatedInitUpdateExpr]:
     ...
 
   @overload
@@ -44840,46 +44260,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.DesignatedI
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DesignatedInitUpdateExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DesignatedInitUpdateExpr]:
     ...
 
 class DesignatedInitExpr(multiplier.ast.Expr):
@@ -44911,7 +44326,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DesignatedInit
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DesignatedInitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DesignatedInitExpr]:
     ...
 
   @overload
@@ -44939,46 +44354,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.DesignatedI
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DesignatedInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DesignatedInitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DesignatedInitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DesignatedInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DesignatedInitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DesignatedInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DesignatedInitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DesignatedInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DesignatedInitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DesignatedInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DesignatedInitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DesignatedInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DesignatedInitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DesignatedInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DesignatedInitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DesignatedInitExpr]:
     ...
 
   def nth_designator(self, n: int) -> Optional[multiplier.ast.Designator]:
@@ -45011,7 +44421,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DependentScope
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DependentScopeDeclRefExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DependentScopeDeclRefExpr]:
     ...
 
   @overload
@@ -45039,46 +44449,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.DependentSc
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DependentScopeDeclRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DependentScopeDeclRefExpr]:
     ...
 
 class DependentCoawaitExpr(multiplier.ast.Expr):
@@ -45103,7 +44508,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DependentCoawa
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DependentCoawaitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DependentCoawaitExpr]:
     ...
 
   @overload
@@ -45131,46 +44536,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.DependentCo
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DependentCoawaitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DependentCoawaitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DependentCoawaitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DependentCoawaitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DependentCoawaitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DependentCoawaitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentCoawaitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DependentCoawaitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DependentCoawaitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DependentCoawaitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DependentCoawaitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DependentCoawaitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DependentCoawaitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DependentCoawaitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DependentCoawaitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DependentCoawaitExpr]:
     ...
 
 class DeclRefExpr(multiplier.ast.Expr):
@@ -45203,7 +44603,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DeclRefExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DeclRefExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DeclRefExpr]:
     ...
 
   @overload
@@ -45231,46 +44631,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.DeclRefExpr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DeclRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DeclRefExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DeclRefExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DeclRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DeclRefExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DeclRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclRefExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DeclRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DeclRefExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DeclRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DeclRefExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DeclRefExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeclRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DeclRefExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DeclRefExpr]:
     ...
 
 class CoroutineSuspendExpr(multiplier.ast.Expr):
@@ -45299,7 +44694,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CoroutineSuspe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CoroutineSuspendExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CoroutineSuspendExpr]:
     ...
 
   @overload
@@ -45327,9 +44722,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CoroutineSu
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CoroutineSuspendExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CoroutineSuspendExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoroutineSuspendExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoroutineSuspendExpr]:
     ...
 
   @overload
@@ -45349,7 +44747,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoroutineSuspendExp
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoroutineSuspendExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoroutineSuspendExpr]:
     ...
 
   @overload
@@ -45357,14 +44755,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CoroutineSuspendExpr]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoroutineSuspendExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoroutineSuspendExpr]:
-    ...
-
 class CoawaitExpr(multiplier.ast.CoroutineSuspendExpr):
   is_implicit: bool
 
@@ -45385,7 +44775,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CoawaitExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CoawaitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CoawaitExpr]:
     ...
 
   @overload
@@ -45413,46 +44803,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CoawaitExpr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CoawaitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CoawaitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoawaitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoawaitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CoawaitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoawaitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoawaitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoawaitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoawaitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CoawaitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CoawaitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoawaitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoawaitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoawaitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoawaitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CoawaitExpr]:
     ...
 
 class CoyieldExpr(multiplier.ast.CoroutineSuspendExpr):
@@ -45474,7 +44859,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CoyieldExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CoyieldExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CoyieldExpr]:
     ...
 
   @overload
@@ -45502,46 +44887,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CoyieldExpr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CoyieldExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CoyieldExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoyieldExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoyieldExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CoyieldExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoyieldExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoyieldExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoyieldExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CoyieldExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CoyieldExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CoyieldExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CoyieldExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CoyieldExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CoyieldExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CoyieldExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CoyieldExpr]:
     ...
 
 class ConvertVectorExpr(multiplier.ast.Expr):
@@ -45566,7 +44946,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ConvertVectorE
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ConvertVectorExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ConvertVectorExpr]:
     ...
 
   @overload
@@ -45594,46 +44974,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ConvertVect
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ConvertVectorExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ConvertVectorExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConvertVectorExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConvertVectorExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ConvertVectorExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConvertVectorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConvertVectorExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConvertVectorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConvertVectorExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ConvertVectorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConvertVectorExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConvertVectorExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConvertVectorExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConvertVectorExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConvertVectorExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConvertVectorExpr]:
     ...
 
 class ConceptSpecializationExpr(multiplier.ast.Expr):
@@ -45663,7 +45038,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ConceptSpecial
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ConceptSpecializationExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ConceptSpecializationExpr]:
     ...
 
   @overload
@@ -45691,9 +45066,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ConceptSpec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ConceptSpecializationExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ConceptSpecializationExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConceptSpecializationExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConceptSpecializationExpr]:
     ...
 
   @overload
@@ -45713,7 +45095,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConceptSpecializati
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConceptSpecializationExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConceptSpecializationExpr]:
     ...
 
   @overload
@@ -45721,18 +45103,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConceptSpecializationExpr]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConceptSpecializationExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConceptSpecializationExpr]:
-    ...
-
   def nth_template_argument(self, n: int) -> Optional[multiplier.ast.TemplateArgument]:
     ...
 
@@ -45758,7 +45128,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CompoundLitera
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CompoundLiteralExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CompoundLiteralExpr]:
     ...
 
   @overload
@@ -45786,46 +45156,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CompoundLit
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CompoundLiteralExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CompoundLiteralExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundLiteralExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CompoundLiteralExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CompoundLiteralExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CompoundLiteralExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CompoundLiteralExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CompoundLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CompoundLiteralExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CompoundLiteralExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CompoundLiteralExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CompoundLiteralExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundLiteralExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CompoundLiteralExpr]:
     ...
 
 class ChooseExpr(multiplier.ast.Expr):
@@ -45855,7 +45220,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ChooseExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ChooseExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ChooseExpr]:
     ...
 
   @overload
@@ -45883,46 +45248,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ChooseExpr]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ChooseExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ChooseExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ChooseExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ChooseExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ChooseExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ChooseExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ChooseExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ChooseExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ChooseExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ChooseExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ChooseExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ChooseExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ChooseExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ChooseExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ChooseExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ChooseExpr]:
     ...
 
 class CharacterLiteral(multiplier.ast.Expr):
@@ -45947,7 +45307,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CharacterLiter
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CharacterLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CharacterLiteral]:
     ...
 
   @overload
@@ -45975,46 +45335,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CharacterLi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CharacterLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CharacterLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CharacterLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CharacterLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CharacterLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CharacterLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CharacterLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CharacterLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CharacterLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CharacterLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CharacterLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CharacterLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CharacterLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CharacterLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CharacterLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CharacterLiteral]:
     ...
 
 class CastExpr(multiplier.ast.Expr):
@@ -46044,7 +45399,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CastExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CastExpr]:
     ...
 
   @overload
@@ -46072,9 +45427,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CastExpr]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CastExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CastExpr]:
     ...
 
   @overload
@@ -46094,7 +45452,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CastExpr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CastExpr]:
     ...
 
   @overload
@@ -46102,14 +45460,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CastExpr]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CastExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CastExpr]:
-    ...
-
 class ImplicitCastExpr(multiplier.ast.CastExpr):
   is_part_of_explicit_cast: bool
 
@@ -46130,7 +45480,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ImplicitCastEx
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ImplicitCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ImplicitCastExpr]:
     ...
 
   @overload
@@ -46158,46 +45508,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ImplicitCas
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ImplicitCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ImplicitCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImplicitCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImplicitCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ImplicitCastExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImplicitCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitCastExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImplicitCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ImplicitCastExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ImplicitCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImplicitCastExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImplicitCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImplicitCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImplicitCastExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImplicitCastExpr]:
     ...
 
 class ExplicitCastExpr(multiplier.ast.CastExpr):
@@ -46220,7 +45565,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ExplicitCastEx
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ExplicitCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ExplicitCastExpr]:
     ...
 
   @overload
@@ -46248,9 +45593,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ExplicitCas
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ExplicitCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ExplicitCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExplicitCastExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExplicitCastExpr]:
     ...
 
   @overload
@@ -46270,7 +45618,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExplicitCastExpr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExplicitCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExplicitCastExpr]:
     ...
 
   @overload
@@ -46278,14 +45626,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExplicitCastExpr]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExplicitCastExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExplicitCastExpr]:
-    ...
-
 class CXXNamedCastExpr(multiplier.ast.ExplicitCastExpr):
   angle_brackets: multiplier.frontend.TokenRange
   cast_name: str
@@ -46309,7 +45649,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXNamedCastEx
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXNamedCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXNamedCastExpr]:
     ...
 
   @overload
@@ -46337,9 +45677,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXNamedCas
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXNamedCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXNamedCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXNamedCastExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNamedCastExpr]:
     ...
 
   @overload
@@ -46359,7 +45702,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNamedCastExpr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXNamedCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXNamedCastExpr]:
     ...
 
   @overload
@@ -46367,14 +45710,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXNamedCastExpr]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXNamedCastExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNamedCastExpr]:
-    ...
-
 class CXXDynamicCastExpr(multiplier.ast.CXXNamedCastExpr):
   is_always_null: bool
 
@@ -46395,7 +45730,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXDynamicCast
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXDynamicCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXDynamicCastExpr]:
     ...
 
   @overload
@@ -46423,46 +45758,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXDynamicC
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXDynamicCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDynamicCastExpr]:
     ...
 
 class CXXConstCastExpr(multiplier.ast.CXXNamedCastExpr):
@@ -46484,7 +45814,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXConstCastEx
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXConstCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXConstCastExpr]:
     ...
 
   @overload
@@ -46512,46 +45842,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXConstCas
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXConstCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXConstCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXConstCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXConstCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXConstCastExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXConstCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConstCastExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXConstCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXConstCastExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXConstCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXConstCastExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConstCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXConstCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXConstCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXConstCastExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXConstCastExpr]:
     ...
 
 class CXXAddrspaceCastExpr(multiplier.ast.CXXNamedCastExpr):
@@ -46573,7 +45898,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXAddrspaceCa
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXAddrspaceCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXAddrspaceCastExpr]:
     ...
 
   @overload
@@ -46601,46 +45926,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXAddrspac
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXAddrspaceCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXAddrspaceCastExpr]:
     ...
 
 class CXXStaticCastExpr(multiplier.ast.CXXNamedCastExpr):
@@ -46662,7 +45982,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXStaticCastE
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXStaticCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXStaticCastExpr]:
     ...
 
   @overload
@@ -46690,46 +46010,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXStaticCa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXStaticCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXStaticCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXStaticCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXStaticCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXStaticCastExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXStaticCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXStaticCastExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXStaticCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXStaticCastExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXStaticCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXStaticCastExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXStaticCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXStaticCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXStaticCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXStaticCastExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXStaticCastExpr]:
     ...
 
 class CXXReinterpretCastExpr(multiplier.ast.CXXNamedCastExpr):
@@ -46751,7 +46066,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXReinterpret
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXReinterpretCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXReinterpretCastExpr]:
     ...
 
   @overload
@@ -46779,46 +46094,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXReinterp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXReinterpretCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXReinterpretCastExpr]:
     ...
 
 class CXXFunctionalCastExpr(multiplier.ast.ExplicitCastExpr):
@@ -46843,7 +46153,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXFunctionalC
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXFunctionalCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXFunctionalCastExpr]:
     ...
 
   @overload
@@ -46871,9 +46181,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXFunction
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXFunctionalCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXFunctionalCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXFunctionalCastExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXFunctionalCastExpr]:
     ...
 
   @overload
@@ -46893,7 +46210,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXFunctionalCastEx
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXFunctionalCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXFunctionalCastExpr]:
     ...
 
   @overload
@@ -46901,18 +46218,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXFunctionalCastExpr]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXFunctionalCastExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXFunctionalCastExpr]:
-    ...
-
 class CStyleCastExpr(multiplier.ast.ExplicitCastExpr):
   l_paren_token: multiplier.frontend.Token
   r_paren_token: multiplier.frontend.Token
@@ -46934,7 +46239,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CStyleCastExpr
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CStyleCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CStyleCastExpr]:
     ...
 
   @overload
@@ -46962,46 +46267,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CStyleCastE
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CStyleCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CStyleCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CStyleCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CStyleCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CStyleCastExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CStyleCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CStyleCastExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CStyleCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CStyleCastExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CStyleCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CStyleCastExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CStyleCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CStyleCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CStyleCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CStyleCastExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CStyleCastExpr]:
     ...
 
 class BuiltinBitCastExpr(multiplier.ast.ExplicitCastExpr):
@@ -47023,7 +46323,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.BuiltinBitCast
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.BuiltinBitCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.BuiltinBitCastExpr]:
     ...
 
   @overload
@@ -47051,46 +46351,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.BuiltinBitC
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.BuiltinBitCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BuiltinBitCastExpr]:
     ...
 
 class ObjCBridgedCastExpr(multiplier.ast.ExplicitCastExpr):
@@ -47116,7 +46411,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCBridgedCas
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCBridgedCastExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCBridgedCastExpr]:
     ...
 
   @overload
@@ -47144,46 +46439,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCBridged
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCBridgedCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCBridgedCastExpr]:
     ...
 
 class CallExpr(multiplier.ast.Expr):
@@ -47222,7 +46512,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CallExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CallExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CallExpr]:
     ...
 
   @overload
@@ -47250,46 +46540,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CallExpr]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CallExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CallExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CallExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CallExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CallExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CallExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CallExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CallExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CallExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CallExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CallExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CallExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CallExpr]:
     ...
 
   def nth_argument(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -47319,7 +46604,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXOperatorCal
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXOperatorCallExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXOperatorCallExpr]:
     ...
 
   @overload
@@ -47347,46 +46632,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXOperator
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXOperatorCallExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXOperatorCallExpr]:
     ...
 
 class CXXMemberCallExpr(multiplier.ast.CallExpr):
@@ -47412,7 +46692,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXMemberCallE
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXMemberCallExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXMemberCallExpr]:
     ...
 
   @overload
@@ -47440,46 +46720,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXMemberCa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXMemberCallExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXMemberCallExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXMemberCallExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXMemberCallExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXMemberCallExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXMemberCallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXMemberCallExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXMemberCallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXMemberCallExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXMemberCallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXMemberCallExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXMemberCallExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXMemberCallExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXMemberCallExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXMemberCallExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXMemberCallExpr]:
     ...
 
 class CUDAKernelCallExpr(multiplier.ast.CallExpr):
@@ -47502,7 +46777,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CUDAKernelCall
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CUDAKernelCallExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CUDAKernelCallExpr]:
     ...
 
   @overload
@@ -47530,46 +46805,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CUDAKernelC
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CUDAKernelCallExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CUDAKernelCallExpr]:
     ...
 
 class UserDefinedLiteral(multiplier.ast.CallExpr):
@@ -47594,7 +46864,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UserDefinedLit
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UserDefinedLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UserDefinedLiteral]:
     ...
 
   @overload
@@ -47622,46 +46892,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UserDefined
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UserDefinedLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UserDefinedLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UserDefinedLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UserDefinedLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UserDefinedLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UserDefinedLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UserDefinedLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UserDefinedLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UserDefinedLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UserDefinedLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UserDefinedLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UserDefinedLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UserDefinedLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UserDefinedLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UserDefinedLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UserDefinedLiteral]:
     ...
 
 class CXXUuidofExpr(multiplier.ast.Expr):
@@ -47688,7 +46953,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXUuidofExpr]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXUuidofExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXUuidofExpr]:
     ...
 
   @overload
@@ -47716,46 +46981,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXUuidofEx
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXUuidofExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXUuidofExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXUuidofExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXUuidofExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXUuidofExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXUuidofExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXUuidofExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXUuidofExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXUuidofExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXUuidofExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXUuidofExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXUuidofExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXUuidofExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXUuidofExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXUuidofExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXUuidofExpr]:
     ...
 
 class CXXUnresolvedConstructExpr(multiplier.ast.Expr):
@@ -47783,7 +47043,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXUnresolvedC
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXUnresolvedConstructExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXUnresolvedConstructExpr]:
     ...
 
   @overload
@@ -47811,46 +47071,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXUnresolv
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXUnresolvedConstructExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXUnresolvedConstructExpr]:
     ...
 
   def nth_argument(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -47881,7 +47136,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXTypeidExpr]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXTypeidExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXTypeidExpr]:
     ...
 
   @overload
@@ -47909,46 +47164,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXTypeidEx
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXTypeidExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXTypeidExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTypeidExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXTypeidExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXTypeidExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTypeidExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXTypeidExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTypeidExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXTypeidExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXTypeidExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXTypeidExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXTypeidExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXTypeidExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXTypeidExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTypeidExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXTypeidExpr]:
     ...
 
 class CXXThrowExpr(multiplier.ast.Expr):
@@ -47973,7 +47223,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXThrowExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXThrowExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXThrowExpr]:
     ...
 
   @overload
@@ -48001,9 +47251,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXThrowExp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXThrowExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXThrowExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXThrowExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXThrowExpr]:
     ...
 
   @overload
@@ -48023,7 +47280,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXThrowExpr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXThrowExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXThrowExpr]:
     ...
 
   @overload
@@ -48031,18 +47288,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXThrowExpr]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXThrowExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXThrowExpr]:
-    ...
-
 class CXXThisExpr(multiplier.ast.Expr):
   token: multiplier.frontend.Token
   is_implicit: bool
@@ -48064,7 +47309,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXThisExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXThisExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXThisExpr]:
     ...
 
   @overload
@@ -48092,46 +47337,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXThisExpr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXThisExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXThisExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXThisExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXThisExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXThisExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXThisExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXThisExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXThisExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXThisExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXThisExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXThisExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXThisExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXThisExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXThisExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXThisExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXThisExpr]:
     ...
 
 class CXXStdInitializerListExpr(multiplier.ast.Expr):
@@ -48154,7 +47394,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXStdInitiali
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXStdInitializerListExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXStdInitializerListExpr]:
     ...
 
   @overload
@@ -48182,46 +47422,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXStdIniti
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXStdInitializerListExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXStdInitializerListExpr]:
     ...
 
 class CXXScalarValueInitExpr(multiplier.ast.Expr):
@@ -48244,7 +47479,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXScalarValue
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXScalarValueInitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXScalarValueInitExpr]:
     ...
 
   @overload
@@ -48272,46 +47507,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXScalarVa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXScalarValueInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXScalarValueInitExpr]:
     ...
 
 class CXXRewrittenBinaryOperator(multiplier.ast.Expr):
@@ -48343,7 +47573,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXRewrittenBi
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXRewrittenBinaryOperator, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXRewrittenBinaryOperator]:
     ...
 
   @overload
@@ -48371,46 +47601,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXRewritte
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXRewrittenBinaryOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXRewrittenBinaryOperator]:
     ...
 
 class CXXPseudoDestructorExpr(multiplier.ast.Expr):
@@ -48440,7 +47665,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXPseudoDestr
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXPseudoDestructorExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXPseudoDestructorExpr]:
     ...
 
   @overload
@@ -48468,46 +47693,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXPseudoDe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXPseudoDestructorExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXPseudoDestructorExpr]:
     ...
 
 class CXXParenListInitExpr(multiplier.ast.Expr):
@@ -48532,7 +47752,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXParenListIn
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXParenListInitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXParenListInitExpr]:
     ...
 
   @overload
@@ -48560,46 +47780,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXParenLis
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXParenListInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXParenListInitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXParenListInitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXParenListInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXParenListInitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXParenListInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXParenListInitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXParenListInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXParenListInitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXParenListInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXParenListInitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXParenListInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXParenListInitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXParenListInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXParenListInitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXParenListInitExpr]:
     ...
 
 class CXXNullPtrLiteralExpr(multiplier.ast.Expr):
@@ -48622,7 +47837,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXNullPtrLite
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXNullPtrLiteralExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXNullPtrLiteralExpr]:
     ...
 
   @overload
@@ -48650,46 +47865,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXNullPtrL
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXNullPtrLiteralExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXNullPtrLiteralExpr]:
     ...
 
 class CXXNoexceptExpr(multiplier.ast.Expr):
@@ -48713,7 +47923,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXNoexceptExp
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXNoexceptExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXNoexceptExpr]:
     ...
 
   @overload
@@ -48741,46 +47951,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXNoexcept
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXNoexceptExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXNoexceptExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNoexceptExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXNoexceptExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXNoexceptExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNoexceptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNoexceptExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNoexceptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXNoexceptExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXNoexceptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXNoexceptExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNoexceptExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXNoexceptExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXNoexceptExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNoexceptExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXNoexceptExpr]:
     ...
 
 class CXXNewExpr(multiplier.ast.Expr):
@@ -48819,7 +48024,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXNewExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXNewExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXNewExpr]:
     ...
 
   @overload
@@ -48847,46 +48052,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXNewExpr]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXNewExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXNewExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNewExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXNewExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXNewExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNewExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNewExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNewExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXNewExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXNewExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXNewExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXNewExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXNewExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXNewExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXNewExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXNewExpr]:
     ...
 
   def nth_placement_argument(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -48916,7 +48116,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXInheritedCt
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXInheritedCtorInitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXInheritedCtorInitExpr]:
     ...
 
   @overload
@@ -48944,46 +48144,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXInherite
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXInheritedCtorInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXInheritedCtorInitExpr]:
     ...
 
 class CXXFoldExpr(multiplier.ast.Expr):
@@ -49016,7 +48211,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXFoldExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXFoldExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXFoldExpr]:
     ...
 
   @overload
@@ -49044,46 +48239,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXFoldExpr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXFoldExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXFoldExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXFoldExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXFoldExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXFoldExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXFoldExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXFoldExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXFoldExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXFoldExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXFoldExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXFoldExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXFoldExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXFoldExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXFoldExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXFoldExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXFoldExpr]:
     ...
 
 class CXXDependentScopeMemberExpr(multiplier.ast.Expr):
@@ -49117,7 +48307,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXDependentSc
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXDependentScopeMemberExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXDependentScopeMemberExpr]:
     ...
 
   @overload
@@ -49145,9 +48335,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXDependen
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXDependentScopeMemberExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]:
     ...
 
   @overload
@@ -49167,7 +48364,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDependentScopeMe
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]:
     ...
 
   @overload
@@ -49175,18 +48372,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDependentScopeMemberExpr]:
-    ...
-
 class CXXDeleteExpr(multiplier.ast.Expr):
   does_usual_array_delete_want_size: bool
   argument: multiplier.ast.Expr
@@ -49213,7 +48398,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXDeleteExpr]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXDeleteExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXDeleteExpr]:
     ...
 
   @overload
@@ -49241,46 +48426,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXDeleteEx
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXDeleteExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXDeleteExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDeleteExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDeleteExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXDeleteExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDeleteExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDeleteExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDeleteExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXDeleteExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXDeleteExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDeleteExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDeleteExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDeleteExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDeleteExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDeleteExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDeleteExpr]:
     ...
 
 class CXXDefaultInitExpr(multiplier.ast.Expr):
@@ -49307,7 +48487,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXDefaultInit
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXDefaultInitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXDefaultInitExpr]:
     ...
 
   @overload
@@ -49335,46 +48515,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXDefaultI
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXDefaultInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDefaultInitExpr]:
     ...
 
 class CXXDefaultArgExpr(multiplier.ast.Expr):
@@ -49401,7 +48576,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXDefaultArgE
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXDefaultArgExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXDefaultArgExpr]:
     ...
 
   @overload
@@ -49429,46 +48604,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXDefaultA
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXDefaultArgExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDefaultArgExpr]:
     ...
 
 class CXXConstructExpr(multiplier.ast.Expr):
@@ -49502,7 +48672,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXConstructEx
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXConstructExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXConstructExpr]:
     ...
 
   @overload
@@ -49530,46 +48700,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXConstruc
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXConstructExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXConstructExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXConstructExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXConstructExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXConstructExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXConstructExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConstructExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXConstructExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXConstructExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXConstructExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXConstructExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConstructExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXConstructExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXConstructExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXConstructExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXConstructExpr]:
     ...
 
   def nth_argument(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -49594,7 +48759,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXTemporaryOb
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXTemporaryObjectExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXTemporaryObjectExpr]:
     ...
 
   @overload
@@ -49622,46 +48787,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXTemporar
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXTemporaryObjectExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXTemporaryObjectExpr]:
     ...
 
 class CXXBoolLiteralExpr(multiplier.ast.Expr):
@@ -49685,7 +48845,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXBoolLiteral
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXBoolLiteralExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXBoolLiteralExpr]:
     ...
 
   @overload
@@ -49713,46 +48873,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXBoolLite
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXBoolLiteralExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXBoolLiteralExpr]:
     ...
 
 class CXXBindTemporaryExpr(multiplier.ast.Expr):
@@ -49775,7 +48930,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXBindTempora
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXBindTemporaryExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXBindTemporaryExpr]:
     ...
 
   @overload
@@ -49803,46 +48958,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXBindTemp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXBindTemporaryExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXBindTemporaryExpr]:
     ...
 
 class BlockExpr(multiplier.ast.Expr):
@@ -49868,7 +49018,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.BlockExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.BlockExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.BlockExpr]:
     ...
 
   @overload
@@ -49896,46 +49046,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.BlockExpr]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.BlockExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.BlockExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BlockExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BlockExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BlockExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BlockExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlockExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BlockExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BlockExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BlockExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BlockExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlockExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BlockExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BlockExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BlockExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BlockExpr]:
     ...
 
 class BinaryOperator(multiplier.ast.Expr):
@@ -49976,7 +49121,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.BinaryOperator
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.BinaryOperator, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.BinaryOperator]:
     ...
 
   @overload
@@ -50004,46 +49149,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.BinaryOpera
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.BinaryOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.BinaryOperator]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BinaryOperator]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BinaryOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BinaryOperator]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BinaryOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BinaryOperator]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BinaryOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BinaryOperator]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BinaryOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BinaryOperator]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BinaryOperator]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BinaryOperator]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BinaryOperator]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BinaryOperator]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BinaryOperator]:
     ...
 
 class CompoundAssignOperator(multiplier.ast.BinaryOperator):
@@ -50067,7 +49207,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CompoundAssign
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CompoundAssignOperator, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CompoundAssignOperator]:
     ...
 
   @overload
@@ -50095,46 +49235,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CompoundAss
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CompoundAssignOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CompoundAssignOperator]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundAssignOperator]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CompoundAssignOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CompoundAssignOperator]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundAssignOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CompoundAssignOperator]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundAssignOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CompoundAssignOperator]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CompoundAssignOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CompoundAssignOperator]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CompoundAssignOperator]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CompoundAssignOperator]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CompoundAssignOperator]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CompoundAssignOperator]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CompoundAssignOperator]:
     ...
 
 class AtomicExpr(multiplier.ast.Expr):
@@ -50173,7 +49308,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.AtomicExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.AtomicExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.AtomicExpr]:
     ...
 
   @overload
@@ -50201,46 +49336,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.AtomicExpr]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.AtomicExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.AtomicExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AtomicExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AtomicExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.AtomicExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AtomicExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AtomicExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AtomicExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AtomicExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.AtomicExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AtomicExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AtomicExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AtomicExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AtomicExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AtomicExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AtomicExpr]:
     ...
 
   def nth_sub_expression(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -50268,7 +49398,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.AsTypeExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.AsTypeExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.AsTypeExpr]:
     ...
 
   @overload
@@ -50296,9 +49426,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.AsTypeExpr]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.AsTypeExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.AsTypeExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AsTypeExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AsTypeExpr]:
     ...
 
   @overload
@@ -50318,7 +49455,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AsTypeExpr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AsTypeExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AsTypeExpr]:
     ...
 
   @overload
@@ -50326,18 +49463,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AsTypeExpr]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AsTypeExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AsTypeExpr]:
-    ...
-
 class ArrayTypeTraitExpr(multiplier.ast.Expr):
   dimension_expression: multiplier.ast.Expr
   queried_type: multiplier.ast.Type
@@ -50361,7 +49486,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ArrayTypeTrait
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ArrayTypeTraitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ArrayTypeTraitExpr]:
     ...
 
   @overload
@@ -50389,46 +49514,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ArrayTypeTr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ArrayTypeTraitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ArrayTypeTraitExpr]:
     ...
 
 class ArraySubscriptExpr(multiplier.ast.Expr):
@@ -50455,7 +49575,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ArraySubscript
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ArraySubscriptExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ArraySubscriptExpr]:
     ...
 
   @overload
@@ -50483,46 +49603,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ArraySubscr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ArraySubscriptExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ArraySubscriptExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArraySubscriptExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ArraySubscriptExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ArraySubscriptExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArraySubscriptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArraySubscriptExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArraySubscriptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArraySubscriptExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ArraySubscriptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ArraySubscriptExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArraySubscriptExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ArraySubscriptExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArraySubscriptExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArraySubscriptExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ArraySubscriptExpr]:
     ...
 
 class ArrayInitLoopExpr(multiplier.ast.Expr):
@@ -50546,7 +49661,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ArrayInitLoopE
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ArrayInitLoopExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ArrayInitLoopExpr]:
     ...
 
   @overload
@@ -50574,46 +49689,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ArrayInitLo
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ArrayInitLoopExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ArrayInitLoopExpr]:
     ...
 
 class ArrayInitIndexExpr(multiplier.ast.Expr):
@@ -50635,7 +49745,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ArrayInitIndex
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ArrayInitIndexExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ArrayInitIndexExpr]:
     ...
 
   @overload
@@ -50663,46 +49773,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ArrayInitIn
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ArrayInitIndexExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ArrayInitIndexExpr]:
     ...
 
 class AddrLabelExpr(multiplier.ast.Expr):
@@ -50727,7 +49832,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.AddrLabelExpr]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.AddrLabelExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.AddrLabelExpr]:
     ...
 
   @overload
@@ -50755,46 +49860,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.AddrLabelEx
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.AddrLabelExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.AddrLabelExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AddrLabelExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AddrLabelExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.AddrLabelExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AddrLabelExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AddrLabelExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AddrLabelExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AddrLabelExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.AddrLabelExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AddrLabelExpr]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AddrLabelExpr]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AddrLabelExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AddrLabelExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AddrLabelExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AddrLabelExpr]:
     ...
 
 class AbstractConditionalOperator(multiplier.ast.Expr):
@@ -50821,7 +49921,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.AbstractCondit
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.AbstractConditionalOperator, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.AbstractConditionalOperator]:
     ...
 
   @overload
@@ -50849,9 +49949,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.AbstractCon
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.AbstractConditionalOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.AbstractConditionalOperator]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AbstractConditionalOperator]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AbstractConditionalOperator]:
     ...
 
   @overload
@@ -50871,7 +49974,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AbstractConditional
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AbstractConditionalOperator]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AbstractConditionalOperator]:
     ...
 
   @overload
@@ -50879,14 +49982,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AbstractConditionalOperator]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AbstractConditionalOperator]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AbstractConditionalOperator]:
-    ...
-
 class ConditionalOperator(multiplier.ast.AbstractConditionalOperator):
   lhs: multiplier.ast.Expr
   rhs: multiplier.ast.Expr
@@ -50908,7 +50003,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ConditionalOpe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ConditionalOperator, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ConditionalOperator]:
     ...
 
   @overload
@@ -50936,46 +50031,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.Conditional
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ConditionalOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ConditionalOperator]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConditionalOperator]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConditionalOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ConditionalOperator]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConditionalOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConditionalOperator]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConditionalOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConditionalOperator]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ConditionalOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConditionalOperator]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConditionalOperator]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConditionalOperator]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConditionalOperator]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConditionalOperator]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConditionalOperator]:
     ...
 
 class BinaryConditionalOperator(multiplier.ast.AbstractConditionalOperator):
@@ -50999,7 +50089,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.BinaryConditio
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.BinaryConditionalOperator, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.BinaryConditionalOperator]:
     ...
 
   @overload
@@ -51027,46 +50117,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.BinaryCondi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.BinaryConditionalOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.BinaryConditionalOperator]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BinaryConditionalOperator]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BinaryConditionalOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BinaryConditionalOperator]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BinaryConditionalOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BinaryConditionalOperator]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BinaryConditionalOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BinaryConditionalOperator]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.BinaryConditionalOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BinaryConditionalOperator]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BinaryConditionalOperator]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BinaryConditionalOperator]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BinaryConditionalOperator]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.BinaryConditionalOperator]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BinaryConditionalOperator]:
     ...
 
 class VAArgExpr(multiplier.ast.Expr):
@@ -51092,7 +50177,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.VAArgExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.VAArgExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.VAArgExpr]:
     ...
 
   @overload
@@ -51120,46 +50205,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.VAArgExpr]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.VAArgExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.VAArgExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.VAArgExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VAArgExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.VAArgExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.VAArgExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VAArgExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.VAArgExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VAArgExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.VAArgExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VAArgExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VAArgExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VAArgExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VAArgExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.VAArgExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VAArgExpr]:
     ...
 
 class UnaryOperator(multiplier.ast.Expr):
@@ -51192,7 +50272,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UnaryOperator]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UnaryOperator, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UnaryOperator]:
     ...
 
   @overload
@@ -51220,46 +50300,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UnaryOperat
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UnaryOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UnaryOperator]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnaryOperator]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnaryOperator]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UnaryOperator]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnaryOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnaryOperator]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnaryOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnaryOperator]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UnaryOperator]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnaryOperator]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnaryOperator]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnaryOperator]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnaryOperator]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnaryOperator]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnaryOperator]:
     ...
 
 class UnaryExprOrTypeTraitExpr(multiplier.ast.Expr):
@@ -51288,7 +50363,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UnaryExprOrTyp
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UnaryExprOrTypeTraitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UnaryExprOrTypeTraitExpr]:
     ...
 
   @overload
@@ -51316,46 +50391,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UnaryExprOr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UnaryExprOrTypeTraitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnaryExprOrTypeTraitExpr]:
     ...
 
 class TypoExpr(multiplier.ast.Expr):
@@ -51377,7 +50447,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TypoExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TypoExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TypoExpr]:
     ...
 
   @overload
@@ -51405,46 +50475,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TypoExpr]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TypoExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TypoExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.TypoExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypoExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.TypoExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.TypoExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypoExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.TypoExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypoExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.TypoExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypoExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypoExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypoExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypoExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.TypoExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypoExpr]:
     ...
 
 class TypeTraitExpr(multiplier.ast.Expr):
@@ -51470,7 +50535,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TypeTraitExpr]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TypeTraitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TypeTraitExpr]:
     ...
 
   @overload
@@ -51498,46 +50563,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TypeTraitEx
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TypeTraitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TypeTraitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.TypeTraitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypeTraitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.TypeTraitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.TypeTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeTraitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.TypeTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeTraitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.TypeTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypeTraitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeTraitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypeTraitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeTraitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.TypeTraitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypeTraitExpr]:
     ...
 
   def nth_argument(self, n: int) -> Optional[multiplier.ast.Type]:
@@ -51566,7 +50626,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SubstNonTypeTe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SubstNonTypeTemplateParmPackExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
     ...
 
   @overload
@@ -51594,46 +50654,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SubstNonTyp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SubstNonTypeTemplateParmPackExpr]:
     ...
 
 class SubstNonTypeTemplateParmExpr(multiplier.ast.Expr):
@@ -51663,7 +50718,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SubstNonTypeTe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SubstNonTypeTemplateParmExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SubstNonTypeTemplateParmExpr]:
     ...
 
   @overload
@@ -51691,46 +50746,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SubstNonTyp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SubstNonTypeTemplateParmExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SubstNonTypeTemplateParmExpr]:
     ...
 
 class StringLiteral(multiplier.ast.Expr):
@@ -51768,7 +50818,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.StringLiteral]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.StringLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.StringLiteral]:
     ...
 
   @overload
@@ -51796,46 +50846,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.StringLiter
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.StringLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.StringLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.StringLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.StringLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.StringLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.StringLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StringLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.StringLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.StringLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.StringLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.StringLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StringLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.StringLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StringLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.StringLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.StringLiteral]:
     ...
 
 class StmtExpr(multiplier.ast.Expr):
@@ -51861,7 +50906,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.StmtExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.StmtExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.StmtExpr]:
     ...
 
   @overload
@@ -51889,46 +50934,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.StmtExpr]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.StmtExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.StmtExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.StmtExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.StmtExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.StmtExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.StmtExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StmtExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.StmtExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.StmtExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.StmtExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.StmtExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StmtExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.StmtExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StmtExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.StmtExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.StmtExpr]:
     ...
 
 class SourceLocExpr(multiplier.ast.Expr):
@@ -51954,7 +50994,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SourceLocExpr]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SourceLocExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SourceLocExpr]:
     ...
 
   @overload
@@ -51982,46 +51022,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SourceLocEx
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SourceLocExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SourceLocExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SourceLocExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SourceLocExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SourceLocExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SourceLocExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SourceLocExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SourceLocExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SourceLocExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SourceLocExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SourceLocExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SourceLocExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SourceLocExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SourceLocExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SourceLocExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SourceLocExpr]:
     ...
 
 class SizeOfPackExpr(multiplier.ast.Expr):
@@ -52050,7 +51085,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SizeOfPackExpr
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SizeOfPackExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SizeOfPackExpr]:
     ...
 
   @overload
@@ -52078,46 +51113,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SizeOfPackE
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SizeOfPackExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SizeOfPackExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SizeOfPackExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SizeOfPackExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SizeOfPackExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SizeOfPackExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SizeOfPackExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SizeOfPackExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SizeOfPackExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SizeOfPackExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SizeOfPackExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SizeOfPackExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SizeOfPackExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SizeOfPackExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SizeOfPackExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SizeOfPackExpr]:
     ...
 
 class ShuffleVectorExpr(multiplier.ast.Expr):
@@ -52141,7 +51171,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ShuffleVectorE
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ShuffleVectorExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ShuffleVectorExpr]:
     ...
 
   @overload
@@ -52169,46 +51199,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ShuffleVect
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ShuffleVectorExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ShuffleVectorExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ShuffleVectorExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ShuffleVectorExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ShuffleVectorExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ShuffleVectorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ShuffleVectorExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ShuffleVectorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ShuffleVectorExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ShuffleVectorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ShuffleVectorExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ShuffleVectorExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ShuffleVectorExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ShuffleVectorExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ShuffleVectorExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ShuffleVectorExpr]:
     ...
 
 class SYCLUniqueStableNameExpr(multiplier.ast.Expr):
@@ -52234,7 +51259,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SYCLUniqueStab
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SYCLUniqueStableNameExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SYCLUniqueStableNameExpr]:
     ...
 
   @overload
@@ -52262,46 +51287,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SYCLUniqueS
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SYCLUniqueStableNameExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SYCLUniqueStableNameExpr]:
     ...
 
 class RequiresExpr(multiplier.ast.Expr):
@@ -52330,7 +51350,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.RequiresExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.RequiresExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.RequiresExpr]:
     ...
 
   @overload
@@ -52358,46 +51378,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.RequiresExp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.RequiresExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.RequiresExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.RequiresExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RequiresExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.RequiresExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.RequiresExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RequiresExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.RequiresExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RequiresExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.RequiresExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.RequiresExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RequiresExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RequiresExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RequiresExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.RequiresExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.RequiresExpr]:
     ...
 
   def nth_local_parameter(self, n: int) -> Optional[multiplier.ast.ParmVarDecl]:
@@ -52424,7 +51439,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.RecoveryExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.RecoveryExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.RecoveryExpr]:
     ...
 
   @overload
@@ -52452,46 +51467,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.RecoveryExp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.RecoveryExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.RecoveryExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.RecoveryExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RecoveryExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.RecoveryExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.RecoveryExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RecoveryExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.RecoveryExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RecoveryExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.RecoveryExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.RecoveryExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RecoveryExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RecoveryExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RecoveryExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.RecoveryExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.RecoveryExpr]:
     ...
 
   def nth_sub_expression(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -52523,7 +51533,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.PseudoObjectEx
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.PseudoObjectExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.PseudoObjectExpr]:
     ...
 
   @overload
@@ -52551,46 +51561,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.PseudoObjec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.PseudoObjectExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.PseudoObjectExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PseudoObjectExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PseudoObjectExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.PseudoObjectExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PseudoObjectExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PseudoObjectExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PseudoObjectExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PseudoObjectExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.PseudoObjectExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PseudoObjectExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PseudoObjectExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PseudoObjectExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PseudoObjectExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PseudoObjectExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PseudoObjectExpr]:
     ...
 
   def nth_semantic(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -52623,7 +51628,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.PredefinedExpr
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.PredefinedExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.PredefinedExpr]:
     ...
 
   @overload
@@ -52651,46 +51656,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.PredefinedE
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.PredefinedExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.PredefinedExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PredefinedExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PredefinedExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.PredefinedExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PredefinedExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PredefinedExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PredefinedExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PredefinedExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.PredefinedExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PredefinedExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PredefinedExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PredefinedExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PredefinedExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PredefinedExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PredefinedExpr]:
     ...
 
 class ParenListExpr(multiplier.ast.Expr):
@@ -52716,7 +51716,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ParenListExpr]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ParenListExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ParenListExpr]:
     ...
 
   @overload
@@ -52744,46 +51744,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ParenListEx
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ParenListExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ParenListExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ParenListExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ParenListExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ParenListExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ParenListExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParenListExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ParenListExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ParenListExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ParenListExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ParenListExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParenListExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ParenListExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParenListExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ParenListExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ParenListExpr]:
     ...
 
   def nth_expression(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -52811,7 +51806,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ParenExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ParenExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ParenExpr]:
     ...
 
   @overload
@@ -52839,46 +51834,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ParenExpr]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ParenExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ParenExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ParenExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ParenExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ParenExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ParenExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParenExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ParenExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ParenExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ParenExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ParenExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParenExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ParenExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParenExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ParenExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ParenExpr]:
     ...
 
 class PackExpansionExpr(multiplier.ast.Expr):
@@ -52902,7 +51892,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.PackExpansionE
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.PackExpansionExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.PackExpansionExpr]:
     ...
 
   @overload
@@ -52930,46 +51920,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.PackExpansi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.PackExpansionExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.PackExpansionExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PackExpansionExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PackExpansionExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.PackExpansionExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PackExpansionExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PackExpansionExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PackExpansionExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PackExpansionExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.PackExpansionExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PackExpansionExpr]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PackExpansionExpr]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PackExpansionExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PackExpansionExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.PackExpansionExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PackExpansionExpr]:
     ...
 
 class OverloadExpr(multiplier.ast.Expr):
@@ -53000,7 +51985,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OverloadExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OverloadExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OverloadExpr]:
     ...
 
   @overload
@@ -53028,9 +52013,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OverloadExp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OverloadExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OverloadExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OverloadExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OverloadExpr]:
     ...
 
   @overload
@@ -53050,7 +52038,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OverloadExpr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OverloadExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OverloadExpr]:
     ...
 
   @overload
@@ -53058,14 +52046,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OverloadExpr]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OverloadExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OverloadExpr]:
-    ...
-
   def nth_declaration(self, n: int) -> Optional[multiplier.ast.NamedDecl]:
     ...
 
@@ -53094,7 +52074,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UnresolvedMemb
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UnresolvedMemberExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UnresolvedMemberExpr]:
     ...
 
   @overload
@@ -53122,46 +52102,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UnresolvedM
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UnresolvedMemberExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnresolvedMemberExpr]:
     ...
 
 class UnresolvedLookupExpr(multiplier.ast.OverloadExpr):
@@ -53185,7 +52160,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UnresolvedLook
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UnresolvedLookupExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UnresolvedLookupExpr]:
     ...
 
   @overload
@@ -53213,46 +52188,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UnresolvedL
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UnresolvedLookupExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnresolvedLookupExpr]:
     ...
 
 class OpaqueValueExpr(multiplier.ast.Expr):
@@ -53277,7 +52247,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OpaqueValueExp
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OpaqueValueExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OpaqueValueExpr]:
     ...
 
   @overload
@@ -53305,46 +52275,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OpaqueValue
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OpaqueValueExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OpaqueValueExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OpaqueValueExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OpaqueValueExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OpaqueValueExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OpaqueValueExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpaqueValueExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OpaqueValueExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OpaqueValueExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OpaqueValueExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OpaqueValueExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OpaqueValueExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OpaqueValueExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OpaqueValueExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OpaqueValueExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OpaqueValueExpr]:
     ...
 
 class OffsetOfExpr(multiplier.ast.Expr):
@@ -53368,7 +52333,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OffsetOfExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OffsetOfExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OffsetOfExpr]:
     ...
 
   @overload
@@ -53396,46 +52361,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OffsetOfExp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OffsetOfExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OffsetOfExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OffsetOfExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OffsetOfExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OffsetOfExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OffsetOfExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OffsetOfExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OffsetOfExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OffsetOfExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OffsetOfExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OffsetOfExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OffsetOfExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OffsetOfExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OffsetOfExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OffsetOfExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OffsetOfExpr]:
     ...
 
 class ObjCSubscriptRefExpr(multiplier.ast.Expr):
@@ -53462,7 +52422,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCSubscriptR
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCSubscriptRefExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCSubscriptRefExpr]:
     ...
 
   @overload
@@ -53490,46 +52450,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCSubscri
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCSubscriptRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCSubscriptRefExpr]:
     ...
 
 class ObjCStringLiteral(multiplier.ast.Expr):
@@ -53553,7 +52508,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCStringLite
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCStringLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCStringLiteral]:
     ...
 
   @overload
@@ -53581,46 +52536,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCStringL
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCStringLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCStringLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCStringLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCStringLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCStringLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCStringLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCStringLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCStringLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCStringLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCStringLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCStringLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCStringLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCStringLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCStringLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCStringLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCStringLiteral]:
     ...
 
 class ObjCSelectorExpr(multiplier.ast.Expr):
@@ -53644,7 +52594,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCSelectorEx
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCSelectorExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCSelectorExpr]:
     ...
 
   @overload
@@ -53672,46 +52622,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCSelecto
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCSelectorExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCSelectorExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCSelectorExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCSelectorExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCSelectorExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCSelectorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCSelectorExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCSelectorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCSelectorExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCSelectorExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCSelectorExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCSelectorExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCSelectorExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCSelectorExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCSelectorExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCSelectorExpr]:
     ...
 
 class ObjCProtocolExpr(multiplier.ast.Expr):
@@ -53737,7 +52682,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCProtocolEx
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCProtocolExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCProtocolExpr]:
     ...
 
   @overload
@@ -53765,9 +52710,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCProtoco
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCProtocolExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCProtocolExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCProtocolExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCProtocolExpr]:
     ...
 
   @overload
@@ -53787,7 +52739,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCProtocolExpr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCProtocolExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCProtocolExpr]:
     ...
 
   @overload
@@ -53795,18 +52747,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCProtocolExpr]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCProtocolExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCProtocolExpr]:
-    ...
-
 class ObjCPropertyRefExpr(multiplier.ast.Expr):
   base: multiplier.ast.Expr
   class_receiver: multiplier.ast.ObjCInterfaceDecl
@@ -53842,7 +52782,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCPropertyRe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCPropertyRefExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCPropertyRefExpr]:
     ...
 
   @overload
@@ -53870,46 +52810,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCPropert
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCPropertyRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCPropertyRefExpr]:
     ...
 
 class ObjCMessageExpr(multiplier.ast.Expr):
@@ -53953,7 +52888,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCMessageExp
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCMessageExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCMessageExpr]:
     ...
 
   @overload
@@ -53981,46 +52916,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCMessage
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCMessageExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCMessageExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCMessageExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCMessageExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCMessageExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCMessageExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCMessageExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCMessageExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCMessageExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCMessageExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCMessageExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCMessageExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCMessageExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCMessageExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCMessageExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCMessageExpr]:
     ...
 
   def nth_argument(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -54054,7 +52984,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCIvarRefExp
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCIvarRefExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCIvarRefExpr]:
     ...
 
   @overload
@@ -54082,46 +53012,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCIvarRef
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCIvarRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCIvarRefExpr]:
     ...
 
 class ObjCIsaExpr(multiplier.ast.Expr):
@@ -54148,7 +53073,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCIsaExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCIsaExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCIsaExpr]:
     ...
 
   @overload
@@ -54176,46 +53101,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCIsaExpr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCIsaExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCIsaExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIsaExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCIsaExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCIsaExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIsaExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIsaExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIsaExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCIsaExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCIsaExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCIsaExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIsaExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCIsaExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIsaExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIsaExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCIsaExpr]:
     ...
 
 class ObjCIndirectCopyRestoreExpr(multiplier.ast.Expr):
@@ -54239,7 +53159,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCIndirectCo
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCIndirectCopyRestoreExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
     ...
 
   @overload
@@ -54267,46 +53187,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCIndirec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCIndirectCopyRestoreExpr]:
     ...
 
 class ObjCEncodeExpr(multiplier.ast.Expr):
@@ -54331,7 +53246,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCEncodeExpr
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCEncodeExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCEncodeExpr]:
     ...
 
   @overload
@@ -54359,46 +53274,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCEncodeE
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCEncodeExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCEncodeExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCEncodeExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCEncodeExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCEncodeExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCEncodeExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCEncodeExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCEncodeExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCEncodeExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCEncodeExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCEncodeExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCEncodeExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCEncodeExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCEncodeExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCEncodeExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCEncodeExpr]:
     ...
 
 class ObjCDictionaryLiteral(multiplier.ast.Expr):
@@ -54421,7 +53331,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCDictionary
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCDictionaryLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCDictionaryLiteral]:
     ...
 
   @overload
@@ -54449,46 +53359,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCDiction
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCDictionaryLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCDictionaryLiteral]:
     ...
 
 class ObjCBoxedExpr(multiplier.ast.Expr):
@@ -54514,7 +53419,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCBoxedExpr]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCBoxedExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCBoxedExpr]:
     ...
 
   @overload
@@ -54542,46 +53447,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCBoxedEx
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCBoxedExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCBoxedExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBoxedExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCBoxedExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCBoxedExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBoxedExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBoxedExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBoxedExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCBoxedExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCBoxedExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCBoxedExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBoxedExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCBoxedExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBoxedExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBoxedExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCBoxedExpr]:
     ...
 
 class ObjCBoolLiteralExpr(multiplier.ast.Expr):
@@ -54605,7 +53505,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCBoolLitera
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCBoolLiteralExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCBoolLiteralExpr]:
     ...
 
   @overload
@@ -54633,46 +53533,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCBoolLit
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCBoolLiteralExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCBoolLiteralExpr]:
     ...
 
 class ObjCAvailabilityCheckExpr(multiplier.ast.Expr):
@@ -54695,7 +53590,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCAvailabili
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCAvailabilityCheckExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCAvailabilityCheckExpr]:
     ...
 
   @overload
@@ -54723,46 +53618,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCAvailab
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCAvailabilityCheckExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAvailabilityCheckExpr]:
     ...
 
 class ObjCArrayLiteral(multiplier.ast.Expr):
@@ -54787,7 +53677,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCArrayLiter
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCArrayLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCArrayLiteral]:
     ...
 
   @overload
@@ -54815,46 +53705,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCArrayLi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCArrayLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCArrayLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCArrayLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCArrayLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCArrayLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCArrayLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCArrayLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCArrayLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCArrayLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ObjCArrayLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCArrayLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCArrayLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCArrayLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCArrayLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ObjCArrayLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCArrayLiteral]:
     ...
 
   def nth_element(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -54882,7 +53767,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPIteratorExp
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPIteratorExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPIteratorExpr]:
     ...
 
   @overload
@@ -54910,9 +53795,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPIterator
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPIteratorExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPIteratorExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPIteratorExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPIteratorExpr]:
     ...
 
   @overload
@@ -54932,7 +53824,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPIteratorExpr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPIteratorExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPIteratorExpr]:
     ...
 
   @overload
@@ -54940,18 +53832,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPIteratorExpr]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPIteratorExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPIteratorExpr]:
-    ...
-
 class OMPArrayShapingExpr(multiplier.ast.Expr):
   base: multiplier.ast.Expr
   num_dimensions: int
@@ -54976,7 +53856,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPArrayShapin
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPArrayShapingExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPArrayShapingExpr]:
     ...
 
   @overload
@@ -55004,46 +53884,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPArraySha
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPArrayShapingExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPArrayShapingExpr]:
     ...
 
   def nth_dimension(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -55075,7 +53950,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPArraySectio
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPArraySectionExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPArraySectionExpr]:
     ...
 
   @overload
@@ -55103,46 +53978,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPArraySec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPArraySectionExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPArraySectionExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPArraySectionExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPArraySectionExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPArraySectionExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPArraySectionExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPArraySectionExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPArraySectionExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPArraySectionExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.OMPArraySectionExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPArraySectionExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPArraySectionExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPArraySectionExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPArraySectionExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.OMPArraySectionExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPArraySectionExpr]:
     ...
 
 class NoInitExpr(multiplier.ast.Expr):
@@ -55164,7 +54034,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.NoInitExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.NoInitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.NoInitExpr]:
     ...
 
   @overload
@@ -55192,46 +54062,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.NoInitExpr]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.NoInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.NoInitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.NoInitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NoInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.NoInitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.NoInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoInitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.NoInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NoInitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.NoInitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NoInitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NoInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NoInitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NoInitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.NoInitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NoInitExpr]:
     ...
 
 class MemberExpr(multiplier.ast.Expr):
@@ -55267,7 +54132,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.MemberExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.MemberExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.MemberExpr]:
     ...
 
   @overload
@@ -55295,46 +54160,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.MemberExpr]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.MemberExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.MemberExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MemberExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MemberExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MemberExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MemberExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MemberExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MemberExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MemberExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MemberExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MemberExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MemberExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MemberExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MemberExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MemberExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MemberExpr]:
     ...
 
 class MatrixSubscriptExpr(multiplier.ast.Expr):
@@ -55361,7 +54221,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.MatrixSubscrip
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.MatrixSubscriptExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.MatrixSubscriptExpr]:
     ...
 
   @overload
@@ -55389,46 +54249,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.MatrixSubsc
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.MatrixSubscriptExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MatrixSubscriptExpr]:
     ...
 
 class MaterializeTemporaryExpr(multiplier.ast.Expr):
@@ -55457,7 +54312,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.MaterializeTem
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.MaterializeTemporaryExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.MaterializeTemporaryExpr]:
     ...
 
   @overload
@@ -55485,46 +54340,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.Materialize
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.MaterializeTemporaryExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MaterializeTemporaryExpr]:
     ...
 
 class MSPropertySubscriptExpr(multiplier.ast.Expr):
@@ -55549,7 +54399,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.MSPropertySubs
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.MSPropertySubscriptExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.MSPropertySubscriptExpr]:
     ...
 
   @overload
@@ -55577,46 +54427,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.MSPropertyS
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.MSPropertySubscriptExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSPropertySubscriptExpr]:
     ...
 
 class MSPropertyRefExpr(multiplier.ast.Expr):
@@ -55643,7 +54488,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.MSPropertyRefE
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.MSPropertyRefExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.MSPropertyRefExpr]:
     ...
 
   @overload
@@ -55671,46 +54516,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.MSPropertyR
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.MSPropertyRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.MSPropertyRefExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSPropertyRefExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSPropertyRefExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MSPropertyRefExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSPropertyRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSPropertyRefExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSPropertyRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSPropertyRefExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.MSPropertyRefExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSPropertyRefExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSPropertyRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSPropertyRefExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSPropertyRefExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.MSPropertyRefExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSPropertyRefExpr]:
     ...
 
 class LambdaExpr(multiplier.ast.Expr):
@@ -55748,7 +54588,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.LambdaExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.LambdaExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.LambdaExpr]:
     ...
 
   @overload
@@ -55776,46 +54616,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.LambdaExpr]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.LambdaExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.LambdaExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.LambdaExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LambdaExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.LambdaExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.LambdaExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LambdaExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.LambdaExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LambdaExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.LambdaExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LambdaExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LambdaExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LambdaExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LambdaExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.LambdaExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LambdaExpr]:
     ...
 
   def nth_explicit_template_parameter(self, n: int) -> Optional[multiplier.ast.NamedDecl]:
@@ -55841,7 +54676,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.IntegerLiteral
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.IntegerLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.IntegerLiteral]:
     ...
 
   @overload
@@ -55869,46 +54704,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.IntegerLite
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.IntegerLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.IntegerLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IntegerLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.IntegerLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.IntegerLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IntegerLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IntegerLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IntegerLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IntegerLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.IntegerLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.IntegerLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IntegerLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.IntegerLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IntegerLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.IntegerLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.IntegerLiteral]:
     ...
 
 class InitListExpr(multiplier.ast.Expr):
@@ -55946,7 +54776,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.InitListExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.InitListExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.InitListExpr]:
     ...
 
   @overload
@@ -55974,46 +54804,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.InitListExp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.InitListExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.InitListExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.InitListExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.InitListExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.InitListExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.InitListExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InitListExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.InitListExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.InitListExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.InitListExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.InitListExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.InitListExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.InitListExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.InitListExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.InitListExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.InitListExpr]:
     ...
 
   def nth_initializer(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -56038,7 +54863,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ImplicitValueI
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ImplicitValueInitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ImplicitValueInitExpr]:
     ...
 
   @overload
@@ -56066,9 +54891,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ImplicitVal
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ImplicitValueInitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ImplicitValueInitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImplicitValueInitExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImplicitValueInitExpr]:
     ...
 
   @overload
@@ -56088,7 +54920,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitValueInitEx
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ImplicitValueInitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImplicitValueInitExpr]:
     ...
 
   @overload
@@ -56096,18 +54928,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImplicitValueInitExpr]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImplicitValueInitExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImplicitValueInitExpr]:
-    ...
-
 class ImaginaryLiteral(multiplier.ast.Expr):
   sub_expression: multiplier.ast.Expr
 
@@ -56128,7 +54948,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ImaginaryLiter
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ImaginaryLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ImaginaryLiteral]:
     ...
 
   @overload
@@ -56156,46 +54976,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ImaginaryLi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ImaginaryLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ImaginaryLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImaginaryLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImaginaryLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ImaginaryLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImaginaryLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImaginaryLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImaginaryLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ImaginaryLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ImaginaryLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImaginaryLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImaginaryLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImaginaryLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImaginaryLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ImaginaryLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImaginaryLiteral]:
     ...
 
 class GenericSelectionExpr(multiplier.ast.Expr):
@@ -56229,7 +55044,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.GenericSelecti
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.GenericSelectionExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.GenericSelectionExpr]:
     ...
 
   @overload
@@ -56257,46 +55072,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.GenericSele
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.GenericSelectionExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.GenericSelectionExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GenericSelectionExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.GenericSelectionExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.GenericSelectionExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GenericSelectionExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GenericSelectionExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GenericSelectionExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.GenericSelectionExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.GenericSelectionExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.GenericSelectionExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GenericSelectionExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.GenericSelectionExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GenericSelectionExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GenericSelectionExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.GenericSelectionExpr]:
     ...
 
   def nth_association_expression(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -56322,7 +55132,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.GNUNullExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.GNUNullExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.GNUNullExpr]:
     ...
 
   @overload
@@ -56350,46 +55160,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.GNUNullExpr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.GNUNullExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.GNUNullExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GNUNullExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.GNUNullExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.GNUNullExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GNUNullExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GNUNullExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GNUNullExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.GNUNullExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.GNUNullExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.GNUNullExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.GNUNullExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.GNUNullExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.GNUNullExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.GNUNullExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.GNUNullExpr]:
     ...
 
 class FunctionParmPackExpr(multiplier.ast.Expr):
@@ -56415,7 +55220,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FunctionParmPa
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FunctionParmPackExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FunctionParmPackExpr]:
     ...
 
   @overload
@@ -56443,46 +55248,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FunctionPar
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FunctionParmPackExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FunctionParmPackExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FunctionParmPackExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FunctionParmPackExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.FunctionParmPackExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FunctionParmPackExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionParmPackExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FunctionParmPackExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FunctionParmPackExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.FunctionParmPackExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FunctionParmPackExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionParmPackExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FunctionParmPackExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionParmPackExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FunctionParmPackExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FunctionParmPackExpr]:
     ...
 
   def nth_expansion(self, n: int) -> Optional[multiplier.ast.VarDecl]:
@@ -56508,7 +55308,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FullExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FullExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FullExpr]:
     ...
 
   @overload
@@ -56536,9 +55336,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FullExpr]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FullExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FullExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FullExpr]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FullExpr]:
     ...
 
   @overload
@@ -56558,7 +55361,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FullExpr]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FullExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FullExpr]:
     ...
 
   @overload
@@ -56566,14 +55369,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FullExpr]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FullExpr]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FullExpr]:
-    ...
-
 class ExprWithCleanups(multiplier.ast.FullExpr):
   cleanups_have_side_effects: bool
 
@@ -56594,7 +55389,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ExprWithCleanu
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ExprWithCleanups, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ExprWithCleanups]:
     ...
 
   @overload
@@ -56622,46 +55417,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ExprWithCle
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ExprWithCleanups]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ExprWithCleanups]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExprWithCleanups]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExprWithCleanups]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ExprWithCleanups]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExprWithCleanups]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExprWithCleanups]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExprWithCleanups]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExprWithCleanups]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ExprWithCleanups]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExprWithCleanups]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExprWithCleanups]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExprWithCleanups]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExprWithCleanups]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExprWithCleanups]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExprWithCleanups]:
     ...
 
 class ConstantExpr(multiplier.ast.FullExpr):
@@ -56686,7 +55476,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ConstantExpr]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ConstantExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ConstantExpr]:
     ...
 
   @overload
@@ -56714,46 +55504,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ConstantExp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ConstantExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ConstantExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConstantExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConstantExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ConstantExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConstantExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstantExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConstantExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConstantExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ConstantExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConstantExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstantExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConstantExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstantExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ConstantExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConstantExpr]:
     ...
 
 class FloatingLiteral(multiplier.ast.Expr):
@@ -56777,7 +55562,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FloatingLitera
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FloatingLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FloatingLiteral]:
     ...
 
   @overload
@@ -56805,46 +55590,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FloatingLit
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FloatingLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FloatingLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FloatingLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FloatingLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.FloatingLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FloatingLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FloatingLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FloatingLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FloatingLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.FloatingLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FloatingLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FloatingLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FloatingLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FloatingLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FloatingLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FloatingLiteral]:
     ...
 
 class FixedPointLiteral(multiplier.ast.Expr):
@@ -56868,7 +55648,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FixedPointLite
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FixedPointLiteral, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FixedPointLiteral]:
     ...
 
   @overload
@@ -56896,46 +55676,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FixedPointL
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FixedPointLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FixedPointLiteral]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FixedPointLiteral]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FixedPointLiteral]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.FixedPointLiteral]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FixedPointLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FixedPointLiteral]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FixedPointLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FixedPointLiteral]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.FixedPointLiteral]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FixedPointLiteral]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FixedPointLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FixedPointLiteral]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FixedPointLiteral]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.FixedPointLiteral]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FixedPointLiteral]:
     ...
 
 class ExtVectorElementExpr(multiplier.ast.Expr):
@@ -56961,7 +55736,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ExtVectorEleme
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ExtVectorElementExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ExtVectorElementExpr]:
     ...
 
   @overload
@@ -56989,46 +55764,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ExtVectorEl
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ExtVectorElementExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ExtVectorElementExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExtVectorElementExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExtVectorElementExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ExtVectorElementExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExtVectorElementExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExtVectorElementExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExtVectorElementExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExtVectorElementExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ExtVectorElementExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExtVectorElementExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExtVectorElementExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExtVectorElementExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExtVectorElementExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExtVectorElementExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExtVectorElementExpr]:
     ...
 
 class ExpressionTraitExpr(multiplier.ast.Expr):
@@ -57053,7 +55823,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ExpressionTrai
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ExpressionTraitExpr, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ExpressionTraitExpr]:
     ...
 
   @overload
@@ -57081,46 +55851,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ExpressionT
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ExpressionTraitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ExpressionTraitExpr]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExpressionTraitExpr]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExpressionTraitExpr]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ExpressionTraitExpr]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExpressionTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExpressionTraitExpr]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExpressionTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExpressionTraitExpr]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.ExpressionTraitExpr]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExpressionTraitExpr]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExpressionTraitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExpressionTraitExpr]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExpressionTraitExpr]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.ExpressionTraitExpr]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExpressionTraitExpr]:
     ...
 
 class AttributedStmt(multiplier.ast.ValueStmt):
@@ -57146,7 +55911,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.AttributedStmt
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.AttributedStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.AttributedStmt]:
     ...
 
   @overload
@@ -57174,46 +55939,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.AttributedS
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.AttributedStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.AttributedStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AttributedStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AttributedStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.AttributedStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AttributedStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AttributedStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AttributedStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AttributedStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.AttributedStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AttributedStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AttributedStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AttributedStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AttributedStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.AttributedStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AttributedStmt]:
     ...
 
   def nth_attribute(self, n: int) -> Optional[multiplier.ast.Attr]:
@@ -57250,7 +56010,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SwitchStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SwitchStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SwitchStmt]:
     ...
 
   @overload
@@ -57278,46 +56038,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SwitchStmt]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SwitchStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SwitchStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SwitchStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SwitchStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SwitchStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SwitchStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwitchStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SwitchStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwitchStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.SwitchStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SwitchStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwitchStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SwitchStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwitchStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SwitchStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SwitchStmt]:
     ...
 
 class SwitchCase(multiplier.ast.Stmt):
@@ -57343,7 +56098,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.SwitchCase]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.SwitchCase, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.SwitchCase]:
     ...
 
   @overload
@@ -57371,9 +56126,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.SwitchCase]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.SwitchCase]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.SwitchCase]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SwitchCase]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SwitchCase]:
     ...
 
   @overload
@@ -57393,7 +56151,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.SwitchCase]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.SwitchCase]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.SwitchCase]:
     ...
 
   @overload
@@ -57401,14 +56159,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.SwitchCase]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.SwitchCase]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.SwitchCase]:
-    ...
-
 class DefaultStmt(multiplier.ast.SwitchCase):
   default_token: multiplier.frontend.Token
 
@@ -57429,7 +56179,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DefaultStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DefaultStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DefaultStmt]:
     ...
 
   @overload
@@ -57457,46 +56207,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.DefaultStmt
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DefaultStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DefaultStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DefaultStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DefaultStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DefaultStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DefaultStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DefaultStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DefaultStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DefaultStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.DefaultStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DefaultStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DefaultStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DefaultStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DefaultStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.DefaultStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DefaultStmt]:
     ...
 
 class CaseStmt(multiplier.ast.SwitchCase):
@@ -57523,7 +56268,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CaseStmt]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CaseStmt, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CaseStmt]:
     ...
 
   @overload
@@ -57551,46 +56296,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CaseStmt]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CaseStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CaseStmt]:
+  def static_kind() -> multiplier.ast.StmtKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CaseStmt]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CaseStmt]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CaseStmt]:
+  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CaseStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CaseStmt]:
+  def FROM(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CaseStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CaseStmt]:
+  def FROM(parent: Optional[multiplier.ast.Stmt]) -> Optional[multiplier.ast.CaseStmt]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CaseStmt]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.StmtKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CaseStmt]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CaseStmt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CaseStmt]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Stmt) -> Optional[multiplier.ast.CaseStmt]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CaseStmt]:
     ...
 
 class Decl(multiplier.Entity):
@@ -57674,12 +56414,12 @@ def IN(file: multiplier.frontend.File, kinds: Sequence[multiplier.ast.DeclKind])
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.Decl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.Decl]:
     ...
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation, kinds: Sequence[multiplier.ast.DeclKind]) -> Iterable[Tuple[multiplier.ast.Decl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation, kinds: Sequence[multiplier.ast.DeclKind]) -> Iterable[multiplier.ast.Decl]:
     ...
 
   @overload
@@ -57707,9 +56447,8 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.Decl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.Decl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.Decl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.Decl]:
     ...
 
   @overload
@@ -57729,7 +56468,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.Decl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.Decl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.Decl]:
     ...
 
   @overload
@@ -57737,10 +56476,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.Decl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.Decl]:
-    ...
-
   def nth_attribute(self, n: int) -> Optional[multiplier.ast.Attr]:
     ...
 
@@ -57772,7 +56507,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CapturedDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CapturedDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CapturedDecl]:
     ...
 
   @overload
@@ -57800,46 +56535,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CapturedDec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CapturedDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CapturedDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CapturedDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CapturedDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CapturedDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CapturedDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapturedDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CapturedDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CapturedDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CapturedDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CapturedDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CapturedDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CapturedDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CapturedDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CapturedDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CapturedDecl]:
     ...
 
   def nth_parameter(self, n: int) -> Optional[multiplier.ast.ImplicitParamDecl]:
@@ -57884,7 +56614,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.BlockDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.BlockDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.BlockDecl]:
     ...
 
   @overload
@@ -57912,46 +56642,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.BlockDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.BlockDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.BlockDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BlockDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BlockDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.BlockDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BlockDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlockDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BlockDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BlockDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.BlockDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BlockDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BlockDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BlockDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BlockDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BlockDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BlockDecl]:
     ...
 
   def nth_parameter(self, n: int) -> Optional[multiplier.ast.ParmVarDecl]:
@@ -57984,7 +56709,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.AccessSpecDecl
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.AccessSpecDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.AccessSpecDecl]:
     ...
 
   @overload
@@ -58012,9 +56737,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.AccessSpecD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.AccessSpecDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.AccessSpecDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AccessSpecDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.AccessSpecDecl]:
     ...
 
   @overload
@@ -58034,7 +56766,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.AccessSpecDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.AccessSpecDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.AccessSpecDecl]:
     ...
 
   @overload
@@ -58042,18 +56774,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.AccessSpecDecl]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.AccessSpecDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.AccessSpecDecl]:
-    ...
-
 class OMPDeclarativeDirectiveDecl(multiplier.ast.Decl):
   canonical_declaration: multiplier.ast.OMPDeclarativeDirectiveDecl
   definition: Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]
@@ -58076,7 +56796,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDeclarative
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDeclarativeDirectiveDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDeclarativeDirectiveDecl]:
     ...
 
   @overload
@@ -58104,9 +56824,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDeclarat
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDeclarativeDirectiveDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]:
     ...
 
   @overload
@@ -58126,7 +56849,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclarativeDirec
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]:
     ...
 
   @overload
@@ -58134,14 +56857,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclarativeDirectiveDecl]:
-    ...
-
 class OMPThreadPrivateDecl(multiplier.ast.OMPDeclarativeDirectiveDecl):
   canonical_declaration: multiplier.ast.OMPThreadPrivateDecl
   definition: Optional[multiplier.ast.OMPThreadPrivateDecl]
@@ -58166,7 +56881,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPThreadPriva
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPThreadPrivateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPThreadPrivateDecl]:
     ...
 
   @overload
@@ -58194,46 +56909,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPThreadPr
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPThreadPrivateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPThreadPrivateDecl]:
     ...
 
   def nth_varlist(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -58261,7 +56971,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPRequiresDec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPRequiresDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPRequiresDecl]:
     ...
 
   @overload
@@ -58289,46 +56999,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPRequires
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPRequiresDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPRequiresDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPRequiresDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPRequiresDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPRequiresDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPRequiresDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPRequiresDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPRequiresDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPRequiresDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPRequiresDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPRequiresDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPRequiresDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPRequiresDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPRequiresDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPRequiresDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPRequiresDecl]:
     ...
 
 class OMPAllocateDecl(multiplier.ast.OMPDeclarativeDirectiveDecl):
@@ -58355,7 +57060,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPAllocateDec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPAllocateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPAllocateDecl]:
     ...
 
   @overload
@@ -58383,46 +57088,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPAllocate
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPAllocateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPAllocateDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPAllocateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPAllocateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPAllocateDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPAllocateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPAllocateDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPAllocateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPAllocateDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPAllocateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPAllocateDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPAllocateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPAllocateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPAllocateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPAllocateDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPAllocateDecl]:
     ...
 
   def nth_varlist(self, n: int) -> Optional[multiplier.ast.Expr]:
@@ -58451,7 +57151,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TranslationUni
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TranslationUnitDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TranslationUnitDecl]:
     ...
 
   @overload
@@ -58479,46 +57179,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.Translation
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TranslationUnitDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TranslationUnitDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TranslationUnitDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TranslationUnitDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TranslationUnitDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TranslationUnitDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TranslationUnitDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TranslationUnitDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TranslationUnitDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TranslationUnitDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TranslationUnitDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TranslationUnitDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TranslationUnitDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TranslationUnitDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TranslationUnitDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TranslationUnitDecl]:
     ...
 
 class TopLevelStmtDecl(multiplier.ast.Decl):
@@ -58545,7 +57240,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TopLevelStmtDe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TopLevelStmtDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TopLevelStmtDecl]:
     ...
 
   @overload
@@ -58573,9 +57268,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TopLevelStm
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TopLevelStmtDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TopLevelStmtDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TopLevelStmtDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TopLevelStmtDecl]:
     ...
 
   @overload
@@ -58595,7 +57297,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TopLevelStmtDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TopLevelStmtDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TopLevelStmtDecl]:
     ...
 
   @overload
@@ -58603,18 +57305,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TopLevelStmtDecl]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TopLevelStmtDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TopLevelStmtDecl]:
-    ...
-
 class StaticAssertDecl(multiplier.ast.Decl):
   canonical_declaration: multiplier.ast.StaticAssertDecl
   definition: Optional[multiplier.ast.StaticAssertDecl]
@@ -58641,7 +57331,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.StaticAssertDe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.StaticAssertDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.StaticAssertDecl]:
     ...
 
   @overload
@@ -58669,46 +57359,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.StaticAsser
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.StaticAssertDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.StaticAssertDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.StaticAssertDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.StaticAssertDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.StaticAssertDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.StaticAssertDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StaticAssertDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.StaticAssertDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.StaticAssertDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.StaticAssertDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.StaticAssertDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.StaticAssertDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.StaticAssertDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.StaticAssertDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.StaticAssertDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.StaticAssertDecl]:
     ...
 
 class RequiresExprBodyDecl(multiplier.ast.Decl):
@@ -58734,7 +57419,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.RequiresExprBo
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.RequiresExprBodyDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.RequiresExprBodyDecl]:
     ...
 
   @overload
@@ -58762,46 +57447,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.RequiresExp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.RequiresExprBodyDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.RequiresExprBodyDecl]:
     ...
 
 class PragmaDetectMismatchDecl(multiplier.ast.Decl):
@@ -58828,7 +57508,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.PragmaDetectMi
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.PragmaDetectMismatchDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.PragmaDetectMismatchDecl]:
     ...
 
   @overload
@@ -58856,46 +57536,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.PragmaDetec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.PragmaDetectMismatchDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PragmaDetectMismatchDecl]:
     ...
 
 class PragmaCommentDecl(multiplier.ast.Decl):
@@ -58922,7 +57597,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.PragmaCommentD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.PragmaCommentDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.PragmaCommentDecl]:
     ...
 
   @overload
@@ -58950,46 +57625,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.PragmaComme
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.PragmaCommentDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.PragmaCommentDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.PragmaCommentDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PragmaCommentDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.PragmaCommentDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.PragmaCommentDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaCommentDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.PragmaCommentDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.PragmaCommentDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.PragmaCommentDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PragmaCommentDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.PragmaCommentDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.PragmaCommentDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.PragmaCommentDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.PragmaCommentDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.PragmaCommentDecl]:
     ...
 
 class ObjCPropertyImplDecl(multiplier.ast.Decl):
@@ -59023,7 +57693,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCPropertyIm
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCPropertyImplDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
   @overload
@@ -59051,46 +57721,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCPropert
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
 class NamedDecl(multiplier.ast.Decl):
@@ -59128,7 +57793,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.NamedDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.NamedDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.NamedDecl]:
     ...
 
   @overload
@@ -59156,9 +57821,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.NamedDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.NamedDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.NamedDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NamedDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamedDecl]:
     ...
 
   @overload
@@ -59178,7 +57846,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NamedDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NamedDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NamedDecl]:
     ...
 
   @overload
@@ -59186,14 +57854,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NamedDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NamedDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamedDecl]:
-    ...
-
   def qualified_name(self, options: multiplier.ast.QualifiedNameRenderOptions) -> multiplier.frontend.TokenRange:
     ...
 
@@ -59224,7 +57884,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.LabelDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.LabelDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.LabelDecl]:
     ...
 
   @overload
@@ -59252,46 +57912,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.LabelDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.LabelDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.LabelDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LabelDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LabelDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.LabelDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LabelDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LabelDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LabelDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LabelDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.LabelDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LabelDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LabelDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LabelDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LabelDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LabelDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LabelDecl]:
     ...
 
 class HLSLBufferDecl(multiplier.ast.NamedDecl):
@@ -59320,7 +57975,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.HLSLBufferDecl
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.HLSLBufferDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.HLSLBufferDecl]:
     ...
 
   @overload
@@ -59348,46 +58003,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.HLSLBufferD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.HLSLBufferDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.HLSLBufferDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.HLSLBufferDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.HLSLBufferDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.HLSLBufferDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.HLSLBufferDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLBufferDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.HLSLBufferDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.HLSLBufferDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.HLSLBufferDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.HLSLBufferDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.HLSLBufferDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.HLSLBufferDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.HLSLBufferDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.HLSLBufferDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.HLSLBufferDecl]:
     ...
 
 class BaseUsingDecl(multiplier.ast.NamedDecl):
@@ -59414,7 +58064,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.BaseUsingDecl]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.BaseUsingDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.BaseUsingDecl]:
     ...
 
   @overload
@@ -59442,9 +58092,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.BaseUsingDe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.BaseUsingDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.BaseUsingDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BaseUsingDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BaseUsingDecl]:
     ...
 
   @overload
@@ -59464,7 +58117,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BaseUsingDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BaseUsingDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BaseUsingDecl]:
     ...
 
   @overload
@@ -59472,14 +58125,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BaseUsingDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BaseUsingDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BaseUsingDecl]:
-    ...
-
   def nth_shadow(self, n: int) -> Optional[multiplier.ast.UsingShadowDecl]:
     ...
 
@@ -59509,7 +58154,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UsingEnumDecl]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UsingEnumDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UsingEnumDecl]:
     ...
 
   @overload
@@ -59537,46 +58182,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UsingEnumDe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UsingEnumDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UsingEnumDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingEnumDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingEnumDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingEnumDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingEnumDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingEnumDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingEnumDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UsingEnumDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingEnumDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingEnumDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingEnumDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingEnumDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingEnumDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingEnumDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingEnumDecl]:
     ...
 
 class UsingDecl(multiplier.ast.BaseUsingDecl):
@@ -59604,7 +58244,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UsingDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UsingDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UsingDecl]:
     ...
 
   @overload
@@ -59632,46 +58272,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UsingDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UsingDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UsingDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UsingDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingDecl]:
     ...
 
 class ValueDecl(multiplier.ast.NamedDecl):
@@ -59700,7 +58335,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ValueDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ValueDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ValueDecl]:
     ...
 
   @overload
@@ -59728,9 +58363,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ValueDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ValueDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ValueDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ValueDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ValueDecl]:
     ...
 
   @overload
@@ -59750,7 +58388,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ValueDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ValueDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ValueDecl]:
     ...
 
   @overload
@@ -59758,14 +58396,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ValueDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ValueDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ValueDecl]:
-    ...
-
 class UnresolvedUsingValueDecl(multiplier.ast.ValueDecl):
   canonical_declaration: multiplier.ast.UnresolvedUsingValueDecl
   definition: Optional[multiplier.ast.UnresolvedUsingValueDecl]
@@ -59792,7 +58422,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UnresolvedUsin
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UnresolvedUsingValueDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UnresolvedUsingValueDecl]:
     ...
 
   @overload
@@ -59820,9 +58450,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UnresolvedU
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UnresolvedUsingValueDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]:
     ...
 
   @overload
@@ -59842,7 +58479,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingValu
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]:
     ...
 
   @overload
@@ -59850,18 +58487,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingValueDecl]:
-    ...
-
 class UnnamedGlobalConstantDecl(multiplier.ast.ValueDecl):
   canonical_declaration: multiplier.ast.UnnamedGlobalConstantDecl
   definition: Optional[multiplier.ast.UnnamedGlobalConstantDecl]
@@ -59884,7 +58509,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UnnamedGlobalC
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UnnamedGlobalConstantDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UnnamedGlobalConstantDecl]:
     ...
 
   @overload
@@ -59912,46 +58537,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UnnamedGlob
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UnnamedGlobalConstantDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnnamedGlobalConstantDecl]:
     ...
 
 class TemplateParamObjectDecl(multiplier.ast.ValueDecl):
@@ -59976,7 +58596,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TemplateParamO
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TemplateParamObjectDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TemplateParamObjectDecl]:
     ...
 
   @overload
@@ -60004,46 +58624,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TemplatePar
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TemplateParamObjectDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TemplateParamObjectDecl]:
     ...
 
 class OMPDeclareReductionDecl(multiplier.ast.ValueDecl):
@@ -60076,7 +58691,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDeclareRedu
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDeclareReductionDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDeclareReductionDecl]:
     ...
 
   @overload
@@ -60104,46 +58719,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDeclareR
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDeclareReductionDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDeclareReductionDecl]:
     ...
 
 class MSGuidDecl(multiplier.ast.ValueDecl):
@@ -60168,7 +58778,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.MSGuidDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.MSGuidDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.MSGuidDecl]:
     ...
 
   @overload
@@ -60196,46 +58806,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.MSGuidDecl]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.MSGuidDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.MSGuidDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.MSGuidDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSGuidDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.MSGuidDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.MSGuidDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSGuidDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.MSGuidDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSGuidDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.MSGuidDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSGuidDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSGuidDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSGuidDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSGuidDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.MSGuidDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSGuidDecl]:
     ...
 
 class IndirectFieldDecl(multiplier.ast.ValueDecl):
@@ -60264,7 +58869,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.IndirectFieldD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.IndirectFieldDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.IndirectFieldDecl]:
     ...
 
   @overload
@@ -60292,46 +58897,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.IndirectFie
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.IndirectFieldDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.IndirectFieldDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.IndirectFieldDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.IndirectFieldDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.IndirectFieldDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.IndirectFieldDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IndirectFieldDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.IndirectFieldDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.IndirectFieldDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.IndirectFieldDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.IndirectFieldDecl]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.IndirectFieldDecl]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.IndirectFieldDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.IndirectFieldDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.IndirectFieldDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.IndirectFieldDecl]:
     ...
 
 class EnumConstantDecl(multiplier.ast.ValueDecl):
@@ -60357,7 +58957,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.EnumConstantDe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.EnumConstantDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.EnumConstantDecl]:
     ...
 
   @overload
@@ -60385,46 +58985,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.EnumConstan
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.EnumConstantDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.EnumConstantDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EnumConstantDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.EnumConstantDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.EnumConstantDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EnumConstantDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumConstantDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EnumConstantDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.EnumConstantDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.EnumConstantDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.EnumConstantDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumConstantDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.EnumConstantDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnumConstantDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EnumConstantDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.EnumConstantDecl]:
     ...
 
 class DeclaratorDecl(multiplier.ast.ValueDecl):
@@ -60456,7 +59051,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DeclaratorDecl
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DeclaratorDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DeclaratorDecl]:
     ...
 
   @overload
@@ -60484,9 +59079,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.DeclaratorD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DeclaratorDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DeclaratorDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DeclaratorDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.DeclaratorDecl]:
     ...
 
   @overload
@@ -60506,7 +59104,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DeclaratorDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DeclaratorDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DeclaratorDecl]:
     ...
 
   @overload
@@ -60514,14 +59112,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DeclaratorDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DeclaratorDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.DeclaratorDecl]:
-    ...
-
   def nth_template_parameter_list(self, n: int) -> Optional[multiplier.ast.TemplateParameterList]:
     ...
 
@@ -60590,7 +59180,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.VarDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.VarDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.VarDecl]:
     ...
 
   @overload
@@ -60618,46 +59208,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.VarDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.VarDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.VarDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VarDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.VarDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VarDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.VarDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VarDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VarDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VarDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VarDecl]:
     ...
 
 class ParmVarDecl(multiplier.ast.VarDecl):
@@ -60698,7 +59283,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ParmVarDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ParmVarDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ParmVarDecl]:
     ...
 
   @overload
@@ -60726,46 +59311,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ParmVarDecl
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ParmVarDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ParmVarDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ParmVarDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ParmVarDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ParmVarDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ParmVarDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParmVarDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ParmVarDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ParmVarDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ParmVarDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ParmVarDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ParmVarDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ParmVarDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ParmVarDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ParmVarDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ParmVarDecl]:
     ...
 
 class OMPCapturedExprDecl(multiplier.ast.VarDecl):
@@ -60790,7 +59370,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPCapturedExp
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPCapturedExprDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPCapturedExprDecl]:
     ...
 
   @overload
@@ -60818,46 +59398,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPCaptured
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPCapturedExprDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPCapturedExprDecl]:
     ...
 
 class ImplicitParamDecl(multiplier.ast.VarDecl):
@@ -60883,7 +59458,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ImplicitParamD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ImplicitParamDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ImplicitParamDecl]:
     ...
 
   @overload
@@ -60911,46 +59486,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ImplicitPar
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ImplicitParamDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ImplicitParamDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImplicitParamDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImplicitParamDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ImplicitParamDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImplicitParamDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitParamDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImplicitParamDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ImplicitParamDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ImplicitParamDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImplicitParamDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitParamDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImplicitParamDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImplicitParamDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImplicitParamDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImplicitParamDecl]:
     ...
 
 class DecompositionDecl(multiplier.ast.VarDecl):
@@ -60977,7 +59547,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.DecompositionD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.DecompositionDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.DecompositionDecl]:
     ...
 
   @overload
@@ -61005,46 +59575,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.Decompositi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.DecompositionDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.DecompositionDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.DecompositionDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DecompositionDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.DecompositionDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.DecompositionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DecompositionDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.DecompositionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.DecompositionDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.DecompositionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DecompositionDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.DecompositionDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.DecompositionDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.DecompositionDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.DecompositionDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.DecompositionDecl]:
     ...
 
   def nth_binding(self, n: int) -> Optional[multiplier.ast.BindingDecl]:
@@ -61081,7 +59646,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.VarTemplateSpe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.VarTemplateSpecializationDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.VarTemplateSpecializationDecl]:
     ...
 
   @overload
@@ -61109,46 +59674,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.VarTemplate
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.VarTemplateSpecializationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VarTemplateSpecializationDecl]:
     ...
 
   def nth_template_argument(self, n: int) -> Optional[multiplier.ast.TemplateArgument]:
@@ -61178,7 +59738,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.VarTemplatePar
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.VarTemplatePartialSpecializationDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.VarTemplatePartialSpecializationDecl]:
     ...
 
   @overload
@@ -61206,46 +59766,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.VarTemplate
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.VarTemplatePartialSpecializationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VarTemplatePartialSpecializationDecl]:
     ...
 
 class NonTypeTemplateParmDecl(multiplier.ast.DeclaratorDecl):
@@ -61280,7 +59835,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.NonTypeTemplat
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.NonTypeTemplateParmDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.NonTypeTemplateParmDecl]:
     ...
 
   @overload
@@ -61308,46 +59863,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.NonTypeTemp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.NonTypeTemplateParmDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NonTypeTemplateParmDecl]:
     ...
 
   def nth_expansion_type(self, n: int) -> Optional[multiplier.ast.Type]:
@@ -61377,7 +59927,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.MSPropertyDecl
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.MSPropertyDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.MSPropertyDecl]:
     ...
 
   @overload
@@ -61405,46 +59955,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.MSPropertyD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.MSPropertyDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.MSPropertyDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.MSPropertyDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSPropertyDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.MSPropertyDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.MSPropertyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSPropertyDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.MSPropertyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.MSPropertyDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.MSPropertyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSPropertyDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.MSPropertyDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.MSPropertyDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.MSPropertyDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.MSPropertyDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.MSPropertyDecl]:
     ...
 
 class FunctionDecl(multiplier.ast.DeclaratorDecl):
@@ -61554,7 +60099,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FunctionDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FunctionDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FunctionDecl]:
     ...
 
   @overload
@@ -61582,46 +60127,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FunctionDec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FunctionDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FunctionDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FunctionDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FunctionDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FunctionDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FunctionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FunctionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FunctionDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FunctionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FunctionDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FunctionDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FunctionDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FunctionDecl]:
     ...
 
   def nth_parameter(self, n: int) -> Optional[multiplier.ast.ParmVarDecl]:
@@ -61671,7 +60211,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXMethodDecl]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXMethodDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXMethodDecl]:
     ...
 
   @overload
@@ -61699,46 +60239,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXMethodDe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXMethodDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXMethodDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXMethodDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXMethodDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXMethodDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXMethodDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXMethodDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXMethodDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXMethodDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXMethodDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXMethodDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXMethodDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXMethodDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXMethodDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXMethodDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXMethodDecl]:
     ...
 
   def nth_overridden_method(self, n: int) -> Optional[multiplier.ast.CXXMethodDecl]:
@@ -61768,7 +60303,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXDestructorD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXDestructorDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXDestructorDecl]:
     ...
 
   @overload
@@ -61796,46 +60331,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXDestruct
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXDestructorDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXDestructorDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXDestructorDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDestructorDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXDestructorDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXDestructorDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDestructorDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXDestructorDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXDestructorDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXDestructorDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDestructorDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDestructorDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDestructorDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDestructorDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXDestructorDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDestructorDecl]:
     ...
 
 class CXXConversionDecl(multiplier.ast.CXXMethodDecl):
@@ -61863,7 +60393,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXConversionD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXConversionDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXConversionDecl]:
     ...
 
   @overload
@@ -61891,46 +60421,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXConversi
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXConversionDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXConversionDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXConversionDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXConversionDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXConversionDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXConversionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConversionDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXConversionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXConversionDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXConversionDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXConversionDecl]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConversionDecl]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXConversionDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXConversionDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXConversionDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXConversionDecl]:
     ...
 
 class CXXConstructorDecl(multiplier.ast.CXXMethodDecl):
@@ -61963,7 +60488,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXConstructor
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXConstructorDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXConstructorDecl]:
     ...
 
   @overload
@@ -61991,46 +60516,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXConstruc
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXConstructorDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXConstructorDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXConstructorDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXConstructorDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXConstructorDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXConstructorDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConstructorDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXConstructorDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXConstructorDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXConstructorDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXConstructorDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXConstructorDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXConstructorDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXConstructorDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXConstructorDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXConstructorDecl]:
     ...
 
   def nth_initializer(self, n: int) -> Optional[multiplier.ast.CXXCtorInitializer]:
@@ -62062,7 +60582,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXDeductionGu
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXDeductionGuideDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXDeductionGuideDecl]:
     ...
 
   @overload
@@ -62090,46 +60610,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXDeductio
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXDeductionGuideDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXDeductionGuideDecl]:
     ...
 
 class FieldDecl(multiplier.ast.DeclaratorDecl):
@@ -62170,7 +60685,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FieldDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FieldDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FieldDecl]:
     ...
 
   @overload
@@ -62198,9 +60713,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FieldDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FieldDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FieldDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FieldDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FieldDecl]:
     ...
 
   @overload
@@ -62220,7 +60742,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FieldDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FieldDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FieldDecl]:
     ...
 
   @overload
@@ -62228,18 +60750,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FieldDecl]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FieldDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FieldDecl]:
-    ...
-
 class ObjCIvarDecl(multiplier.ast.FieldDecl):
   canonical_declaration: multiplier.ast.ObjCIvarDecl
   definition: Optional[multiplier.ast.ObjCIvarDecl]
@@ -62267,7 +60777,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCIvarDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCIvarDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCIvarDecl]:
     ...
 
   @overload
@@ -62295,46 +60805,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCIvarDec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCIvarDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCIvarDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCIvarDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCIvarDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCIvarDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCIvarDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIvarDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCIvarDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCIvarDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCIvarDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCIvarDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCIvarDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCIvarDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCIvarDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCIvarDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCIvarDecl]:
     ...
 
 class ObjCAtDefsFieldDecl(multiplier.ast.FieldDecl):
@@ -62359,7 +60864,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCAtDefsFiel
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCAtDefsFieldDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCAtDefsFieldDecl]:
     ...
 
   @overload
@@ -62387,46 +60892,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCAtDefsF
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCAtDefsFieldDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCAtDefsFieldDecl]:
     ...
 
 class BindingDecl(multiplier.ast.ValueDecl):
@@ -62454,7 +60954,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.BindingDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.BindingDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.BindingDecl]:
     ...
 
   @overload
@@ -62482,46 +60982,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.BindingDecl
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.BindingDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.BindingDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BindingDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BindingDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.BindingDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BindingDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BindingDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BindingDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BindingDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.BindingDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BindingDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BindingDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BindingDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BindingDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BindingDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BindingDecl]:
     ...
 
 class OMPDeclarativeDirectiveValueDecl(multiplier.ast.ValueDecl):
@@ -62546,7 +61041,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDeclarative
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDeclarativeDirectiveValueDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
     ...
 
   @overload
@@ -62574,9 +61069,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDeclarat
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
     ...
 
   @overload
@@ -62596,7 +61094,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclarativeDirec
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
     ...
 
   @overload
@@ -62604,14 +61102,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclarativeDirectiveValueDecl]:
-    ...
-
 class OMPDeclareMapperDecl(multiplier.ast.OMPDeclarativeDirectiveValueDecl):
   canonical_declaration: multiplier.ast.OMPDeclareMapperDecl
   definition: Optional[multiplier.ast.OMPDeclareMapperDecl]
@@ -62636,7 +61126,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.OMPDeclareMapp
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.OMPDeclareMapperDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.OMPDeclareMapperDecl]:
     ...
 
   @overload
@@ -62664,46 +61154,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.OMPDeclareM
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.OMPDeclareMapperDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.OMPDeclareMapperDecl]:
     ...
 
 class UsingShadowDecl(multiplier.ast.NamedDecl):
@@ -62731,7 +61216,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UsingShadowDec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UsingShadowDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UsingShadowDecl]:
     ...
 
   @overload
@@ -62759,46 +61244,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UsingShadow
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UsingShadowDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UsingShadowDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingShadowDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingShadowDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingShadowDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingShadowDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingShadowDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingShadowDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UsingShadowDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingShadowDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingShadowDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingShadowDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingShadowDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingShadowDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingShadowDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingShadowDecl]:
     ...
 
 class ConstructorUsingShadowDecl(multiplier.ast.UsingShadowDecl):
@@ -62828,7 +61308,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ConstructorUsi
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ConstructorUsingShadowDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ConstructorUsingShadowDecl]:
     ...
 
   @overload
@@ -62856,46 +61336,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.Constructor
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ConstructorUsingShadowDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConstructorUsingShadowDecl]:
     ...
 
 class UsingPackDecl(multiplier.ast.NamedDecl):
@@ -62922,7 +61397,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UsingPackDecl]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UsingPackDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UsingPackDecl]:
     ...
 
   @overload
@@ -62950,46 +61425,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UsingPackDe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UsingPackDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UsingPackDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingPackDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingPackDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingPackDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingPackDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingPackDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingPackDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UsingPackDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingPackDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingPackDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingPackDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingPackDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingPackDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingPackDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingPackDecl]:
     ...
 
   def nth_expansion(self, n: int) -> Optional[multiplier.ast.NamedDecl]:
@@ -63022,7 +61492,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UsingDirective
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UsingDirectiveDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UsingDirectiveDecl]:
     ...
 
   @overload
@@ -63050,46 +61520,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UsingDirect
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UsingDirectiveDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UsingDirectiveDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingDirectiveDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingDirectiveDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingDirectiveDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingDirectiveDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingDirectiveDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingDirectiveDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UsingDirectiveDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UsingDirectiveDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingDirectiveDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UsingDirectiveDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UsingDirectiveDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UsingDirectiveDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UsingDirectiveDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UsingDirectiveDecl]:
     ...
 
 class UnresolvedUsingIfExistsDecl(multiplier.ast.NamedDecl):
@@ -63114,7 +61579,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UnresolvedUsin
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UnresolvedUsingIfExistsDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UnresolvedUsingIfExistsDecl]:
     ...
 
   @overload
@@ -63142,46 +61607,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UnresolvedU
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UnresolvedUsingIfExistsDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnresolvedUsingIfExistsDecl]:
     ...
 
 class TypeDecl(multiplier.ast.NamedDecl):
@@ -63207,7 +61667,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TypeDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TypeDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TypeDecl]:
     ...
 
   @overload
@@ -63235,9 +61695,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TypeDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TypeDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TypeDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypeDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeDecl]:
     ...
 
   @overload
@@ -63257,7 +61720,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeDecl]:
     ...
 
   @overload
@@ -63265,14 +61728,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypeDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypeDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeDecl]:
-    ...
-
 class TemplateTypeParmDecl(multiplier.ast.TypeDecl):
   canonical_declaration: multiplier.ast.TemplateTypeParmDecl
   definition: Optional[multiplier.ast.TemplateTypeParmDecl]
@@ -63306,7 +61761,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TemplateTypePa
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TemplateTypeParmDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TemplateTypeParmDecl]:
     ...
 
   @overload
@@ -63334,46 +61789,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TemplateTyp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TemplateTypeParmDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TemplateTypeParmDecl]:
     ...
 
 class TagDecl(multiplier.ast.TypeDecl):
@@ -63420,7 +61870,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TagDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TagDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TagDecl]:
     ...
 
   @overload
@@ -63448,9 +61898,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TagDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TagDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TagDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TagDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TagDecl]:
     ...
 
   @overload
@@ -63470,7 +61923,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TagDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TagDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TagDecl]:
     ...
 
   @overload
@@ -63478,14 +61931,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TagDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TagDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TagDecl]:
-    ...
-
   def nth_template_parameter_list(self, n: int) -> Optional[multiplier.ast.TemplateParameterList]:
     ...
 
@@ -63537,7 +61982,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.RecordDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.RecordDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.RecordDecl]:
     ...
 
   @overload
@@ -63565,46 +62010,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.RecordDecl]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.RecordDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.RecordDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RecordDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RecordDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.RecordDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RecordDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RecordDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RecordDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RecordDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.RecordDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.RecordDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RecordDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RecordDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RecordDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RecordDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.RecordDecl]:
     ...
 
   def nth_field(self, n: int) -> Optional[multiplier.ast.FieldDecl]:
@@ -63757,7 +62197,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.CXXRecordDecl]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.CXXRecordDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.CXXRecordDecl]:
     ...
 
   @overload
@@ -63785,46 +62225,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.CXXRecordDe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.CXXRecordDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.CXXRecordDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXRecordDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXRecordDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXRecordDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXRecordDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXRecordDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXRecordDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.CXXRecordDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.CXXRecordDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXRecordDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.CXXRecordDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.CXXRecordDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.CXXRecordDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.CXXRecordDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.CXXRecordDecl]:
     ...
 
   def nth_constructor(self, n: int) -> Optional[multiplier.ast.CXXConstructorDecl]:
@@ -63861,7 +62296,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ClassTemplateS
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ClassTemplateSpecializationDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ClassTemplateSpecializationDecl]:
     ...
 
   @overload
@@ -63889,46 +62324,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ClassTempla
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ClassTemplateSpecializationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ClassTemplateSpecializationDecl]:
     ...
 
   def nth_template_argument(self, n: int) -> Optional[multiplier.ast.TemplateArgument]:
@@ -63959,7 +62389,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ClassTemplateP
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ClassTemplatePartialSpecializationDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
     ...
 
   @overload
@@ -63987,9 +62417,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ClassTempla
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
     ...
 
   @overload
@@ -64009,7 +62446,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ClassTemplatePartia
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
     ...
 
   @overload
@@ -64017,18 +62454,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplatePartialSpecializationDecl]:
-    ...
-
 class EnumDecl(multiplier.ast.TagDecl):
   canonical_declaration: multiplier.ast.EnumDecl
   definition: Optional[multiplier.ast.EnumDecl]
@@ -64063,7 +62488,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.EnumDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.EnumDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.EnumDecl]:
     ...
 
   @overload
@@ -64091,46 +62516,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.EnumDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.EnumDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.EnumDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EnumDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.EnumDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.EnumDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EnumDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EnumDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.EnumDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.EnumDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.EnumDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EnumDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.EnumDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EnumDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EnumDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.EnumDecl]:
     ...
 
   def nth_enumerator(self, n: int) -> Optional[multiplier.ast.EnumConstantDecl]:
@@ -64162,7 +62582,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.UnresolvedUsin
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.UnresolvedUsingTypenameDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.UnresolvedUsingTypenameDecl]:
     ...
 
   @overload
@@ -64190,46 +62610,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.UnresolvedU
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.UnresolvedUsingTypenameDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.UnresolvedUsingTypenameDecl]:
     ...
 
 class TypedefNameDecl(multiplier.ast.TypeDecl):
@@ -64258,7 +62673,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TypedefNameDec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TypedefNameDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TypedefNameDecl]:
     ...
 
   @overload
@@ -64286,9 +62701,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TypedefName
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TypedefNameDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TypedefNameDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypedefNameDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypedefNameDecl]:
     ...
 
   @overload
@@ -64308,7 +62726,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypedefNameDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypedefNameDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypedefNameDecl]:
     ...
 
   @overload
@@ -64316,14 +62734,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypedefNameDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypedefNameDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypedefNameDecl]:
-    ...
-
 class TypedefDecl(multiplier.ast.TypedefNameDecl):
   canonical_declaration: multiplier.ast.TypedefDecl
   definition: Optional[multiplier.ast.TypedefDecl]
@@ -64346,7 +62756,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TypedefDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TypedefDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TypedefDecl]:
     ...
 
   @overload
@@ -64374,46 +62784,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TypedefDecl
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TypedefDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TypedefDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypedefDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypedefDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TypedefDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypedefDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypedefDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypedefDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypedefDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TypedefDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypedefDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypedefDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypedefDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypedefDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypedefDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypedefDecl]:
     ...
 
 class TypeAliasDecl(multiplier.ast.TypedefNameDecl):
@@ -64439,7 +62844,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TypeAliasDecl]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TypeAliasDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TypeAliasDecl]:
     ...
 
   @overload
@@ -64467,46 +62872,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TypeAliasDe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TypeAliasDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TypeAliasDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeAliasDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypeAliasDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TypeAliasDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeAliasDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeAliasDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeAliasDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeAliasDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TypeAliasDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypeAliasDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeAliasDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypeAliasDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeAliasDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeAliasDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypeAliasDecl]:
     ...
 
 class ObjCTypeParamDecl(multiplier.ast.TypedefNameDecl):
@@ -64536,7 +62936,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCTypeParamD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCTypeParamDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCTypeParamDecl]:
     ...
 
   @overload
@@ -64564,46 +62964,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCTypePar
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCTypeParamDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCTypeParamDecl]:
     ...
 
 class TemplateDecl(multiplier.ast.NamedDecl):
@@ -64632,7 +63027,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TemplateDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TemplateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TemplateDecl]:
     ...
 
   @overload
@@ -64660,9 +63055,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TemplateDec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TemplateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TemplateDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateDecl]:
     ...
 
   @overload
@@ -64682,7 +63080,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TemplateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateDecl]:
     ...
 
   @overload
@@ -64690,14 +63088,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TemplateDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TemplateDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateDecl]:
-    ...
-
 class RedeclarableTemplateDecl(multiplier.ast.TemplateDecl):
   canonical_declaration: multiplier.ast.RedeclarableTemplateDecl
   definition: Optional[multiplier.ast.RedeclarableTemplateDecl]
@@ -64721,7 +63111,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.RedeclarableTe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.RedeclarableTemplateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.RedeclarableTemplateDecl]:
     ...
 
   @overload
@@ -64749,9 +63139,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.Redeclarabl
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.RedeclarableTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.RedeclarableTemplateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RedeclarableTemplateDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RedeclarableTemplateDecl]:
     ...
 
   @overload
@@ -64771,7 +63164,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.RedeclarableTemplat
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.RedeclarableTemplateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.RedeclarableTemplateDecl]:
     ...
 
   @overload
@@ -64779,14 +63172,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.RedeclarableTemplateDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.RedeclarableTemplateDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.RedeclarableTemplateDecl]:
-    ...
-
 class FunctionTemplateDecl(multiplier.ast.RedeclarableTemplateDecl):
   canonical_declaration: multiplier.ast.FunctionTemplateDecl
   definition: Optional[multiplier.ast.FunctionTemplateDecl]
@@ -64811,7 +63196,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FunctionTempla
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FunctionTemplateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FunctionTemplateDecl]:
     ...
 
   @overload
@@ -64839,46 +63224,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FunctionTem
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FunctionTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FunctionTemplateDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FunctionTemplateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FunctionTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FunctionTemplateDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FunctionTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionTemplateDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FunctionTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FunctionTemplateDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FunctionTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FunctionTemplateDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FunctionTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FunctionTemplateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FunctionTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FunctionTemplateDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FunctionTemplateDecl]:
     ...
 
 class ClassTemplateDecl(multiplier.ast.RedeclarableTemplateDecl):
@@ -64904,7 +63284,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ClassTemplateD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ClassTemplateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ClassTemplateDecl]:
     ...
 
   @overload
@@ -64932,46 +63312,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ClassTempla
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ClassTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ClassTemplateDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ClassTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ClassTemplateDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ClassTemplateDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ClassTemplateDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ClassTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ClassTemplateDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ClassTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ClassTemplateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ClassTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ClassTemplateDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ClassTemplateDecl]:
     ...
 
 class VarTemplateDecl(multiplier.ast.RedeclarableTemplateDecl):
@@ -64997,7 +63372,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.VarTemplateDec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.VarTemplateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.VarTemplateDecl]:
     ...
 
   @overload
@@ -65025,46 +63400,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.VarTemplate
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.VarTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.VarTemplateDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VarTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.VarTemplateDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarTemplateDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.VarTemplateDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.VarTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VarTemplateDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.VarTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.VarTemplateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.VarTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.VarTemplateDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.VarTemplateDecl]:
     ...
 
 class TypeAliasTemplateDecl(multiplier.ast.RedeclarableTemplateDecl):
@@ -65089,7 +63459,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TypeAliasTempl
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TypeAliasTemplateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TypeAliasTemplateDecl]:
     ...
 
   @overload
@@ -65117,46 +63487,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TypeAliasTe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TypeAliasTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TypeAliasTemplateDecl]:
     ...
 
 class ConceptDecl(multiplier.ast.TemplateDecl):
@@ -65183,7 +63548,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ConceptDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ConceptDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ConceptDecl]:
     ...
 
   @overload
@@ -65211,9 +63576,16 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ConceptDecl
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ConceptDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ConceptDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
+    ...
+
+  @staticmethod
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConceptDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ConceptDecl]:
     ...
 
   @overload
@@ -65233,7 +63605,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ConceptDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ConceptDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ConceptDecl]:
     ...
 
   @overload
@@ -65241,18 +63613,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ConceptDecl]:
     ...
 
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ConceptDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ConceptDecl]:
-    ...
-
 class BuiltinTemplateDecl(multiplier.ast.TemplateDecl):
   canonical_declaration: multiplier.ast.BuiltinTemplateDecl
   definition: Optional[multiplier.ast.BuiltinTemplateDecl]
@@ -65275,7 +63635,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.BuiltinTemplat
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.BuiltinTemplateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.BuiltinTemplateDecl]:
     ...
 
   @overload
@@ -65303,46 +63663,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.BuiltinTemp
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.BuiltinTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.BuiltinTemplateDecl]:
     ...
 
 class TemplateTemplateParmDecl(multiplier.ast.TemplateDecl):
@@ -65372,7 +63727,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.TemplateTempla
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.TemplateTemplateParmDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.TemplateTemplateParmDecl]:
     ...
 
   @overload
@@ -65400,46 +63755,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.TemplateTem
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.TemplateTemplateParmDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.TemplateTemplateParmDecl]:
     ...
 
 class ObjCPropertyDecl(multiplier.ast.NamedDecl):
@@ -65482,7 +63832,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCPropertyDe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCPropertyDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCPropertyDecl]:
     ...
 
   @overload
@@ -65510,46 +63860,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCPropert
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCPropertyDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCPropertyDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCPropertyDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCPropertyDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCPropertyDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCPropertyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPropertyDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCPropertyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCPropertyDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCPropertyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCPropertyDecl]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCPropertyDecl]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCPropertyDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCPropertyDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCPropertyDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCPropertyDecl]:
     ...
 
 class ObjCMethodDecl(multiplier.ast.NamedDecl):
@@ -65608,7 +63953,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCMethodDecl
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCMethodDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCMethodDecl]:
     ...
 
   @overload
@@ -65636,46 +63981,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCMethodD
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCMethodDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCMethodDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCMethodDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCMethodDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCMethodDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCMethodDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCMethodDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCMethodDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCMethodDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCMethodDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCMethodDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCMethodDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCMethodDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCMethodDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCMethodDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCMethodDecl]:
     ...
 
   def nth_parameter(self, n: int) -> Optional[multiplier.ast.ParmVarDecl]:
@@ -65721,7 +64061,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCContainerD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCContainerDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCContainerDecl]:
     ...
 
   @overload
@@ -65749,9 +64089,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCContain
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCContainerDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCContainerDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCContainerDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCContainerDecl]:
     ...
 
   @overload
@@ -65771,7 +64114,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCContainerDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCContainerDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCContainerDecl]:
     ...
 
   @overload
@@ -65779,14 +64122,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCContainerDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCContainerDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCContainerDecl]:
-    ...
-
   def nth_class_method(self, n: int) -> Optional[multiplier.ast.ObjCMethodDecl]:
     ...
 
@@ -65840,7 +64175,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCCategoryDe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCCategoryDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCCategoryDecl]:
     ...
 
   @overload
@@ -65868,46 +64203,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCCategor
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCCategoryDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCCategoryDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCategoryDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCCategoryDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCCategoryDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCategoryDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCCategoryDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCategoryDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCCategoryDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCCategoryDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCCategoryDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCCategoryDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCCategoryDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCCategoryDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCategoryDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCCategoryDecl]:
     ...
 
   def nth_instance_variable(self, n: int) -> Optional[multiplier.ast.ObjCIvarDecl]:
@@ -65949,7 +64279,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCProtocolDe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCProtocolDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCProtocolDecl]:
     ...
 
   @overload
@@ -65977,46 +64307,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCProtoco
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCProtocolDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCProtocolDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCProtocolDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCProtocolDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCProtocolDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCProtocolDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCProtocolDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCProtocolDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCProtocolDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCProtocolDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCProtocolDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCProtocolDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCProtocolDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCProtocolDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCProtocolDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCProtocolDecl]:
     ...
 
   def nth_protocol_token(self, n: int) -> Optional[multiplier.frontend.Token]:
@@ -66077,7 +64402,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCInterfaceD
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCInterfaceDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCInterfaceDecl]:
     ...
 
   @overload
@@ -66105,46 +64430,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCInterfa
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCInterfaceDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCInterfaceDecl]:
     ...
 
   def nth_all_referenced_protocol(self, n: int) -> Optional[multiplier.ast.ObjCProtocolDecl]:
@@ -66196,7 +64516,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCImplDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCImplDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCImplDecl]:
     ...
 
   @overload
@@ -66224,9 +64544,12 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCImplDec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCImplDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCImplDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCImplDecl]:
+    ...
+
+  @staticmethod
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCImplDecl]:
     ...
 
   @overload
@@ -66246,7 +64569,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCImplDecl]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCImplDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCImplDecl]:
     ...
 
   @overload
@@ -66254,14 +64577,6 @@ def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.
   def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCImplDecl]:
     ...
 
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCImplDecl]:
-    ...
-
-  @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCImplDecl]:
-    ...
-
   def nth_property_implementation(self, n: int) -> Optional[multiplier.ast.ObjCPropertyImplDecl]:
     ...
 
@@ -66289,7 +64604,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCCategoryIm
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCCategoryImplDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCCategoryImplDecl]:
     ...
 
   @overload
@@ -66317,46 +64632,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCCategor
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCCategoryImplDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
     ...
 
+  @overload
   @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
-    ...
-
-  @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCCategoryImplDecl]:
     ...
 
 class ObjCImplementationDecl(multiplier.ast.ObjCImplDecl):
@@ -66392,7 +64702,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCImplementa
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCImplementationDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCImplementationDecl]:
     ...
 
   @overload
@@ -66420,46 +64730,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCImpleme
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCImplementationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCImplementationDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCImplementationDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCImplementationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCImplementationDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCImplementationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCImplementationDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCImplementationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCImplementationDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCImplementationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCImplementationDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCImplementationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCImplementationDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCImplementationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCImplementationDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCImplementationDecl]:
     ...
 
   def nth_initializer(self, n: int) -> Optional[multiplier.ast.CXXCtorInitializer]:
@@ -66491,7 +64796,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ObjCCompatible
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ObjCCompatibleAliasDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ObjCCompatibleAliasDecl]:
     ...
 
   @overload
@@ -66519,46 +64824,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ObjCCompati
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ObjCCompatibleAliasDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ObjCCompatibleAliasDecl]:
     ...
 
 class NamespaceDecl(multiplier.ast.NamedDecl):
@@ -66588,7 +64888,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.NamespaceDecl]
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.NamespaceDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.NamespaceDecl]:
     ...
 
   @overload
@@ -66616,46 +64916,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.NamespaceDe
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.NamespaceDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.NamespaceDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamespaceDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NamespaceDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.NamespaceDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamespaceDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NamespaceDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamespaceDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NamespaceDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.NamespaceDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NamespaceDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NamespaceDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NamespaceDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NamespaceDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamespaceDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NamespaceDecl]:
     ...
 
 class NamespaceAliasDecl(multiplier.ast.NamedDecl):
@@ -66685,7 +64980,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.NamespaceAlias
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.NamespaceAliasDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.NamespaceAliasDecl]:
     ...
 
   @overload
@@ -66713,46 +65008,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.NamespaceAl
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.NamespaceAliasDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.NamespaceAliasDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamespaceAliasDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NamespaceAliasDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.NamespaceAliasDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamespaceAliasDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NamespaceAliasDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamespaceAliasDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.NamespaceAliasDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.NamespaceAliasDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NamespaceAliasDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.NamespaceAliasDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.NamespaceAliasDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.NamespaceAliasDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.NamespaceAliasDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.NamespaceAliasDecl]:
     ...
 
 class LinkageSpecDecl(multiplier.ast.Decl):
@@ -66782,7 +65072,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.LinkageSpecDec
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.LinkageSpecDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.LinkageSpecDecl]:
     ...
 
   @overload
@@ -66810,46 +65100,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.LinkageSpec
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.LinkageSpecDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.LinkageSpecDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LinkageSpecDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LinkageSpecDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.LinkageSpecDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LinkageSpecDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LinkageSpecDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LinkageSpecDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LinkageSpecDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.LinkageSpecDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LinkageSpecDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LinkageSpecDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LinkageSpecDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LinkageSpecDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LinkageSpecDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LinkageSpecDecl]:
     ...
 
 class LifetimeExtendedTemporaryDecl(multiplier.ast.Decl):
@@ -66879,7 +65164,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.LifetimeExtend
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.LifetimeExtendedTemporaryDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.LifetimeExtendedTemporaryDecl]:
     ...
 
   @overload
@@ -66907,46 +65192,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.LifetimeExt
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.LifetimeExtendedTemporaryDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.LifetimeExtendedTemporaryDecl]:
     ...
 
 class ImportDecl(multiplier.ast.Decl):
@@ -66973,7 +65253,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ImportDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ImportDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ImportDecl]:
     ...
 
   @overload
@@ -67001,46 +65281,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ImportDecl]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ImportDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ImportDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImportDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImportDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ImportDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImportDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImportDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImportDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ImportDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ImportDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImportDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImportDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImportDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImportDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImportDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImportDecl]:
     ...
 
   def nth_identifier_token(self, n: int) -> Optional[multiplier.frontend.Token]:
@@ -67070,7 +65345,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ImplicitConcep
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ImplicitConceptSpecializationDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ImplicitConceptSpecializationDecl]:
     ...
 
   @overload
@@ -67098,46 +65373,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ImplicitCon
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ImplicitConceptSpecializationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ImplicitConceptSpecializationDecl]:
     ...
 
   def nth_template_argument(self, n: int) -> Optional[multiplier.ast.TemplateArgument]:
@@ -67170,7 +65440,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FriendTemplate
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FriendTemplateDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FriendTemplateDecl]:
     ...
 
   @overload
@@ -67198,46 +65468,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FriendTempl
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FriendTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FriendTemplateDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FriendTemplateDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FriendTemplateDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FriendTemplateDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FriendTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FriendTemplateDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FriendTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FriendTemplateDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FriendTemplateDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FriendTemplateDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FriendTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FriendTemplateDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FriendTemplateDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FriendTemplateDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FriendTemplateDecl]:
     ...
 
   def nth_template_parameter_list(self, n: int) -> Optional[multiplier.ast.TemplateParameterList]:
@@ -67272,7 +65537,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FriendDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FriendDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FriendDecl]:
     ...
 
   @overload
@@ -67300,46 +65565,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FriendDecl]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FriendDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FriendDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FriendDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FriendDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FriendDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FriendDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FriendDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FriendDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FriendDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FriendDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FriendDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FriendDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FriendDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FriendDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FriendDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FriendDecl]:
     ...
 
   def nth_friend_type_template_parameter_list(self, n: int) -> Optional[multiplier.ast.TemplateParameterList]:
@@ -67370,7 +65630,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.FileScopeAsmDe
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.FileScopeAsmDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.FileScopeAsmDecl]:
     ...
 
   @overload
@@ -67398,46 +65658,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.FileScopeAs
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.FileScopeAsmDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.FileScopeAsmDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FileScopeAsmDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FileScopeAsmDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FileScopeAsmDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FileScopeAsmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FileScopeAsmDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FileScopeAsmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.FileScopeAsmDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.FileScopeAsmDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FileScopeAsmDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.FileScopeAsmDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.FileScopeAsmDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.FileScopeAsmDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.FileScopeAsmDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.FileScopeAsmDecl]:
     ...
 
 class ExternCContextDecl(multiplier.ast.Decl):
@@ -67463,7 +65718,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ExternCContext
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ExternCContextDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ExternCContextDecl]:
     ...
 
   @overload
@@ -67491,46 +65746,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ExternCCont
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ExternCContextDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ExternCContextDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ExternCContextDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExternCContextDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ExternCContextDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ExternCContextDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExternCContextDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ExternCContextDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExternCContextDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ExternCContextDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExternCContextDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExternCContextDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExternCContextDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExternCContextDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ExternCContextDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExternCContextDecl]:
     ...
 
 class ExportDecl(multiplier.ast.Decl):
@@ -67559,7 +65809,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.ExportDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.ExportDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.ExportDecl]:
     ...
 
   @overload
@@ -67587,46 +65837,41 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.ExportDecl]
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.ExportDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.ExportDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ExportDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExportDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ExportDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ExportDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExportDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ExportDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.ExportDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.ExportDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExportDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.ExportDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.ExportDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.ExportDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.ExportDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.ExportDecl]:
     ...
 
 class EmptyDecl(multiplier.ast.Decl):
@@ -67651,7 +65896,7 @@ def IN(file: multiplier.frontend.File) -> Iterable[multiplier.ast.EmptyDecl]:
 
   @overload
   @staticmethod
-  def IN(tu: multiplier.frontend.Compilation) -> Iterable[Tuple[multiplier.ast.EmptyDecl, multiplier.ir.Operation]]:
+  def IN(tu: multiplier.frontend.Compilation) -> Iterable[multiplier.ast.EmptyDecl]:
     ...
 
   @overload
@@ -67679,44 +65924,39 @@ def containing(stmt: multiplier.ast.Stmt) -> Iterable[multiplier.ast.EmptyDecl]:
   def containing(stmt: Optional[multiplier.ast.Stmt]) -> Iterable[multiplier.ast.EmptyDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(op: multiplier.ir.Operation) -> Optional[multiplier.ast.EmptyDecl]:
+  def static_kind() -> multiplier.ast.DeclKind:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EmptyDecl]:
+  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.EmptyDecl]:
     ...
 
-  @overload
   @staticmethod
-  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.EmptyDecl]:
+  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EmptyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EmptyDecl]:
+  def FROM(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EmptyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.ast.EmptyDecl]:
+  def FROM(parent: Optional[multiplier.ast.Decl]) -> Optional[multiplier.ast.EmptyDecl]:
     ...
 
   @overload
   @staticmethod
-  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.EmptyDecl]:
-    ...
-
-  @staticmethod
-  def static_kind() -> multiplier.ast.DeclKind:
+  def FROM(r: multiplier.Reference) -> Optional[multiplier.ast.EmptyDecl]:
     ...
 
+  @overload
   @staticmethod
-  def by_id(arg_0: multiplier.Index, arg_1: int) -> Optional[multiplier.ast.EmptyDecl]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.ast.EmptyDecl]:
     ...
 
+  @overload
   @staticmethod
-  def from_base(parent: multiplier.ast.Decl) -> Optional[multiplier.ast.EmptyDecl]:
+  def FROM(t: multiplier.frontend.TokenContext) -> Optional[multiplier.ast.EmptyDecl]:
     ...
diff --git a/bindings/Python/multiplier-stubs/frontend/__init__.py b/bindings/Python/multiplier-stubs/frontend/__init__.py
index 22322dcfc..c419f8ff1 100644
--- a/bindings/Python/multiplier-stubs/frontend/__init__.py
+++ b/bindings/Python/multiplier-stubs/frontend/__init__.py
@@ -12,18 +12,8 @@
 from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
 import pathlib
 import multiplier
-import multiplier.ir
 import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
 import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
 
 class MacroKind(IntEnum):
   SUBSTITUTION = 0
@@ -653,7 +643,6 @@ class TokenContext(object):
   parent: Optional[multiplier.frontend.TokenContext]
 
 class Compilation(multiplier.Entity):
-  ir: Optional[multiplier.ir.builtin.ModuleOp]
   fragments: Iterable[multiplier.Fragment]
   files: Iterable[multiplier.frontend.File]
   defines: Iterable[multiplier.frontend.DefineMacroDirective]
@@ -737,7 +726,7 @@ def containing(arg_0: multiplier.frontend.Macro) -> multiplier.frontend.Compilat
 
   @overload
   @staticmethod
-  def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.Compilation]:
+  def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.Compilation]:
     ...
 
   @staticmethod
@@ -758,7 +747,7 @@ class Token(multiplier.Entity):
   containing_macro: Optional[multiplier.frontend.Macro]
 
   @staticmethod
-  def FROM(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.Token]:
+  def FROM(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.Token]:
     ...
 
   @staticmethod
@@ -766,7 +755,7 @@ def entity_category() -> multiplier.EntityCategory:
     ...
 
   @staticmethod
-  def categorize(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> multiplier.frontend.TokenCategory:
+  def categorize(entity: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> multiplier.frontend.TokenCategory:
     ...
 
   def location(self, arg_0: multiplier.frontend.FileLocationCache) -> Optional[Tuple[int, int]]:
@@ -910,11 +899,6 @@ def containing(entity: multiplier.ast.Designator) -> Optional[multiplier.fronten
   def containing(entity: multiplier.ast.CXXCtorInitializer) -> Optional[multiplier.frontend.File]:
     ...
 
-  @overload
-  @staticmethod
-  def containing(entity: multiplier.ir.Operation) -> Optional[multiplier.frontend.File]:
-    ...
-
   @overload
   @staticmethod
   def containing(token: multiplier.frontend.Token) -> Optional[multiplier.frontend.File]:
@@ -932,11 +916,11 @@ def containing(tokens: multiplier.frontend.TokenTree) -> Optional[multiplier.fro
 
   @overload
   @staticmethod
-  def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.File]:
+  def containing(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.File]:
     ...
 
   @staticmethod
-  def FROM(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.File]:
+  def FROM(arg_0: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.File]:
     ...
 
   @staticmethod
@@ -1022,7 +1006,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.Macro]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.Macro]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.Macro]:
     ...
 
   @overload
@@ -1091,7 +1075,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroSubstitut
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroSubstitution]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroSubstitution]:
     ...
 
   @overload
@@ -1156,7 +1140,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroConcatena
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroConcatenate]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroConcatenate]:
     ...
 
   @overload
@@ -1221,7 +1205,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroStringify
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroStringify]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroStringify]:
     ...
 
   @overload
@@ -1289,7 +1273,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroExpansion
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroExpansion]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroExpansion]:
     ...
 
   @overload
@@ -1358,7 +1342,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroParameter
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroParameterSubstitution]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroParameterSubstitution]:
     ...
 
   @overload
@@ -1423,7 +1407,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroVAOpt]:
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroVAOpt]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroVAOpt]:
     ...
 
   @overload
@@ -1487,7 +1471,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroVAOptArgu
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroVAOptArgument]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroVAOptArgument]:
     ...
 
   @overload
@@ -1553,7 +1537,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroArgument]
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroArgument]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroArgument]:
     ...
 
   @overload
@@ -1620,7 +1604,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroParameter
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroParameter]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroParameter]:
     ...
 
   @overload
@@ -1682,7 +1666,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.MacroDirective
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.MacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.MacroDirective]:
     ...
 
   @overload
@@ -1753,7 +1737,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.DefineMacroDir
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.DefineMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.DefineMacroDirective]:
     ...
 
   @overload
@@ -1817,7 +1801,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.PragmaMacroDir
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.PragmaMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.PragmaMacroDirective]:
     ...
 
   @overload
@@ -1881,7 +1865,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.UndefineMacroD
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.UndefineMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.UndefineMacroDirective]:
     ...
 
   @overload
@@ -1945,7 +1929,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.OtherMacroDire
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.OtherMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.OtherMacroDirective]:
     ...
 
   @overload
@@ -2005,7 +1989,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ConditionalMac
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.ConditionalMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ConditionalMacroDirective]:
     ...
 
   @overload
@@ -2069,7 +2053,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.EndIfMacroDire
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.EndIfMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.EndIfMacroDirective]:
     ...
 
   @overload
@@ -2133,7 +2117,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ElseMacroDirec
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.ElseMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ElseMacroDirective]:
     ...
 
   @overload
@@ -2197,7 +2181,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ElseIfNotDefin
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.ElseIfNotDefinedMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ElseIfNotDefinedMacroDirective]:
     ...
 
   @overload
@@ -2261,7 +2245,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ElseIfDefinedM
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.ElseIfDefinedMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ElseIfDefinedMacroDirective]:
     ...
 
   @overload
@@ -2325,7 +2309,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ElseIfMacroDir
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.ElseIfMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ElseIfMacroDirective]:
     ...
 
   @overload
@@ -2389,7 +2373,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IfNotDefinedMa
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.IfNotDefinedMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IfNotDefinedMacroDirective]:
     ...
 
   @overload
@@ -2453,7 +2437,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IfDefinedMacro
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.IfDefinedMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IfDefinedMacroDirective]:
     ...
 
   @overload
@@ -2517,7 +2501,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IfMacroDirecti
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.IfMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IfMacroDirective]:
     ...
 
   @overload
@@ -2578,7 +2562,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IncludeLikeMac
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.IncludeLikeMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IncludeLikeMacroDirective]:
     ...
 
   @overload
@@ -2642,7 +2626,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.ImportMacroDir
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.ImportMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.ImportMacroDirective]:
     ...
 
   @overload
@@ -2706,7 +2690,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IncludeMacrosM
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.IncludeMacrosMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IncludeMacrosMacroDirective]:
     ...
 
   @overload
@@ -2770,7 +2754,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IncludeNextMac
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.IncludeNextMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IncludeNextMacroDirective]:
     ...
 
   @overload
@@ -2834,7 +2818,7 @@ def FROM(r: multiplier.Reference) -> Optional[multiplier.frontend.IncludeMacroDi
 
   @overload
   @staticmethod
-  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation | multiplier.ir.Operation]) -> Optional[multiplier.frontend.IncludeMacroDirective]:
+  def FROM(e: Optional[multiplier.Fragment | multiplier.ast.Decl | multiplier.ast.Stmt | multiplier.ast.Attr | multiplier.frontend.Macro | multiplier.ast.Type | multiplier.frontend.File | multiplier.frontend.Token | multiplier.ast.TemplateArgument | multiplier.ast.TemplateParameterList | multiplier.ast.CXXBaseSpecifier | multiplier.ast.Designator | multiplier.ast.CXXCtorInitializer | multiplier.frontend.Compilation]) -> Optional[multiplier.frontend.IncludeMacroDirective]:
     ...
 
   @overload
diff --git a/bindings/Python/multiplier-stubs/ir/__init__.py b/bindings/Python/multiplier-stubs/ir/__init__.py
deleted file mode 100644
index 45d966867..000000000
--- a/bindings/Python/multiplier-stubs/ir/__init__.py
+++ /dev/null
@@ -1,867 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class AttributeKind(IntEnum):
-  UNKNOWN = 0
-  BUILTIN_TYPED = 1
-  BUILTIN_ELEMENTS = 2
-  BUILTIN_AFFINE_MAP = 3
-  BUILTIN_ARRAY = 4
-  BUILTIN_DENSE_ARRAY = 5
-  BUILTIN_DENSE_INT_OR_FP_ELEMENTS = 6
-  BUILTIN_DENSE_STRING_ELEMENTS = 7
-  BUILTIN_DENSE_RESOURCE_ELEMENTS = 8
-  BUILTIN_DICTIONARY = 9
-  BUILTIN_FLOAT = 10
-  BUILTIN_INTEGER = 11
-  BUILTIN_INTEGER_SET = 12
-  BUILTIN_OPAQUE = 13
-  BUILTIN_SPARSE_ELEMENTS = 14
-  BUILTIN_STRIDED_LAYOUT = 15
-  BUILTIN_STRING = 16
-  BUILTIN_SYMBOL_REF = 17
-  BUILTIN_TYPE = 18
-  BUILTIN_UNIT = 19
-  BUILTIN_BOOL = 20
-  BUILTIN_FLAT_SYMBOL_REF = 21
-  BUILTIN_DENSE_INT_ELEMENTS = 22
-  BUILTIN_DATA_LAYOUT_SPEC = 23
-  LLVM_C_CONV = 24
-  LLVM_COMDAT = 25
-  LLVM_LINKAGE = 26
-  LLVM_FRAME_POINTER_KIND = 27
-  LLVM_LOOP_VECTORIZE = 28
-  LLVM_LOOP_INTERLEAVE = 29
-  LLVM_LOOP_UNROLL = 30
-  LLVM_LOOP_UNROLL_AND_JAM = 31
-  LLVM_LOOP_LICM = 32
-  LLVM_LOOP_DISTRIBUTE = 33
-  LLVM_LOOP_PIPELINE = 34
-  LLVM_LOOP_PEELED = 35
-  LLVM_LOOP_UNSWITCH = 36
-  LLVM_LOOP_ANNOTATION = 37
-  LLVM_DI_EXPRESSION_ELEM = 38
-  LLVM_DI_EXPRESSION = 39
-  LLVM_DI_NULL_TYPE = 40
-  LLVM_DI_BASIC_TYPE = 41
-  LLVM_DI_COMPILE_UNIT = 42
-  LLVM_DI_COMPOSITE_TYPE = 43
-  LLVM_DI_DERIVED_TYPE = 44
-  LLVM_DI_FILE = 45
-  LLVM_DI_GLOBAL_VARIABLE_EXPRESSION = 46
-  LLVM_DI_GLOBAL_VARIABLE = 47
-  LLVM_DI_LEXICAL_BLOCK = 48
-  LLVM_DI_LEXICAL_BLOCK_FILE = 49
-  LLVM_DI_LOCAL_VARIABLE = 50
-  LLVM_DI_SUBPROGRAM = 51
-  LLVM_DI_MODULE = 52
-  LLVM_DI_NAMESPACE = 53
-  LLVM_DI_SUBRANGE = 54
-  LLVM_DI_SUBROUTINE_TYPE = 55
-  LLVM_DI_LABEL = 56
-  LLVM_MEMORY_EFFECTS = 57
-  LLVM_ALIAS_SCOPE_DOMAIN = 58
-  LLVM_ALIAS_SCOPE = 59
-  LLVM_ACCESS_GROUP = 60
-  LLVM_TBAA_ROOT = 61
-  LLVM_TBAA_MEMBER = 62
-  LLVM_TBAA_TYPE_DESCRIPTOR = 63
-  LLVM_TBAA_TAG = 64
-  LLVM_V_SCALE_RANGE = 65
-  LLVM_TARGET_FEATURES = 66
-  LLVM_INTEGER_OVERFLOW_FLAGS = 67
-  LLVM_FASTMATH_FLAGS = 68
-  HL_ANNOTATION = 69
-  HL_FORMAT = 70
-  HL_SECTION = 71
-  HL_ALIAS = 72
-  HL_ERROR = 73
-  HL_COUNTED_BY = 74
-  HL_CLEANUP = 75
-  HL_ALIGNED = 76
-  HL_ALWAYS_INLINE = 77
-  HL_NO_INLINE = 78
-  HL_CONST = 79
-  HL_LOADER_UNINITIALIZED = 80
-  HL_NO_INSTRUMENT_FUNCTION = 81
-  HL_PACKED = 82
-  HL_PURE = 83
-  HL_WARN_UNUSED_RESULT = 84
-  HL_RESTRICT = 85
-  HL_NO_THROW = 86
-  HL_NON_NULL = 87
-  HL_LEAF = 88
-  HL_COLD = 89
-  HL_TRANSPARENT_UNION = 90
-  HL_RETURNS_TWICE = 91
-  HL_MAY_ALIAS = 92
-  HL_UNUSED = 93
-  HL_USED = 94
-  HL_GNU_INLINE = 95
-  HL_NO_CF_CHECK = 96
-  HL_AVAILABLE_ONLY_IN_DEFAULT_EVAL_METHOD = 97
-  HL_AVAILABILITY_ATTR = 98
-  HL_FALLTHROUGH = 99
-  HL_NO_PROFILE_INSTRUMENT_FUNCTION = 100
-  HL_ASM_LABEL = 101
-  HL_MODE = 102
-  HL_BUILTIN = 103
-  HL_ALLOC_ALIGN = 104
-  HL_ALLOC_SIZE = 105
-  HL_DEPRECATED = 106
-  HL_MAX_FIELD_ALIGNMENT = 107
-  HL_VISIBILITY = 108
-  HL_ASSUME_ALIGNED = 109
-  HL_CV_QUALIFIERS = 110
-  HL_UCV_QUALIFIERS = 111
-  HL_CVR_QUALIFIERS = 112
-  HL_OFFSET_OF_NODE = 113
-  CORE_BOOLEAN = 114
-  CORE_INTEGER = 115
-  CORE_FLOAT = 116
-  CORE_VOID = 117
-  CORE_SOURCE_LANGUAGE = 118
-  CORE_GLOBAL_LINKAGE_KIND = 119
-  META_IDENTIFIER = 120
-
-class ValueKind(IntEnum):
-  OPERATION_RESULT = 0
-  BLOCK_ARGUMENT = 1
-
-class OperationKind(IntEnum):
-  UNKNOWN = 0
-  BUILTIN_MODULE = 1
-  BUILTIN_UNREALIZED_CONVERSION_CAST = 2
-  LLVM_ASHR = 3
-  LLVM_ADD = 4
-  LLVM_ADDRSPACECAST = 5
-  LLVM_MLIR_ADDRESSOF = 6
-  LLVM_ALLOCA = 7
-  LLVM_AND = 8
-  LLVM_CMPXCHG = 9
-  LLVM_ATOMICRMW = 10
-  LLVM_BITCAST = 11
-  LLVM_BR = 12
-  LLVM_CALL_INTRINSIC = 13
-  LLVM_CALL = 14
-  LLVM_COMDAT = 15
-  LLVM_COMDAT_SELECTOR = 16
-  LLVM_COND_BR = 17
-  LLVM_MLIR_CONSTANT = 18
-  LLVM_EXTRACTELEMENT = 19
-  LLVM_EXTRACTVALUE = 20
-  LLVM_FADD = 21
-  LLVM_FCMP = 22
-  LLVM_FDIV = 23
-  LLVM_FMUL = 24
-  LLVM_FNEG = 25
-  LLVM_FPEXT = 26
-  LLVM_FPTOSI = 27
-  LLVM_FPTOUI = 28
-  LLVM_FPTRUNC = 29
-  LLVM_FREM = 30
-  LLVM_FSUB = 31
-  LLVM_FENCE = 32
-  LLVM_FREEZE = 33
-  LLVM_GETELEMENTPTR = 34
-  LLVM_MLIR_GLOBAL_CTORS = 35
-  LLVM_MLIR_GLOBAL_DTORS = 36
-  LLVM_MLIR_GLOBAL = 37
-  LLVM_ICMP = 38
-  LLVM_INLINE_ASM = 39
-  LLVM_INSERTELEMENT = 40
-  LLVM_INSERTVALUE = 41
-  LLVM_INTTOPTR = 42
-  LLVM_INVOKE = 43
-  LLVM_FUNC = 44
-  LLVM_LSHR = 45
-  LLVM_LANDINGPAD = 46
-  LLVM_LINKER_OPTIONS = 47
-  LLVM_LOAD = 48
-  LLVM_MUL = 49
-  LLVM_MLIR_NONE = 50
-  LLVM_OR = 51
-  LLVM_MLIR_POISON = 52
-  LLVM_PTRTOINT = 53
-  LLVM_RESUME = 54
-  LLVM_RETURN = 55
-  LLVM_SDIV = 56
-  LLVM_SEXT = 57
-  LLVM_SITOFP = 58
-  LLVM_SREM = 59
-  LLVM_SELECT = 60
-  LLVM_SHL = 61
-  LLVM_SHUFFLEVECTOR = 62
-  LLVM_STORE = 63
-  LLVM_SUB = 64
-  LLVM_SWITCH = 65
-  LLVM_TRUNC = 66
-  LLVM_UDIV = 67
-  LLVM_UITOFP = 68
-  LLVM_UREM = 69
-  LLVM_MLIR_UNDEF = 70
-  LLVM_UNREACHABLE = 71
-  LLVM_XOR = 72
-  LLVM_ZEXT = 73
-  LLVM_MLIR_ZERO = 74
-  LLVM_INTR_ABS = 75
-  LLVM_INTR_ANNOTATION = 76
-  LLVM_INTR_ASSUME = 77
-  LLVM_INTR_BITREVERSE = 78
-  LLVM_INTR_BSWAP = 79
-  LLVM_INTR_COPYSIGN = 80
-  LLVM_INTR_CORO_ALIGN = 81
-  LLVM_INTR_CORO_BEGIN = 82
-  LLVM_INTR_CORO_END = 83
-  LLVM_INTR_CORO_FREE = 84
-  LLVM_INTR_CORO_ID = 85
-  LLVM_INTR_CORO_PROMISE = 86
-  LLVM_INTR_CORO_RESUME = 87
-  LLVM_INTR_CORO_SAVE = 88
-  LLVM_INTR_CORO_SIZE = 89
-  LLVM_INTR_CORO_SUSPEND = 90
-  LLVM_INTR_COS = 91
-  LLVM_INTR_CTLZ = 92
-  LLVM_INTR_CTTZ = 93
-  LLVM_INTR_CTPOP = 94
-  LLVM_INTR_DBG_DECLARE = 95
-  LLVM_INTR_DBG_LABEL = 96
-  LLVM_INTR_DBG_VALUE = 97
-  LLVM_INTR_DEBUGTRAP = 98
-  LLVM_INTR_EH_TYPEID_FOR = 99
-  LLVM_INTR_EXP2 = 100
-  LLVM_INTR_EXP = 101
-  LLVM_INTR_EXPECT = 102
-  LLVM_INTR_EXPECT_WITH_PROBABILITY = 103
-  LLVM_INTR_FABS = 104
-  LLVM_INTR_CEIL = 105
-  LLVM_INTR_FLOOR = 106
-  LLVM_INTR_FMA = 107
-  LLVM_INTR_FMULADD = 108
-  LLVM_INTR_TRUNC = 109
-  LLVM_INTR_FSHL = 110
-  LLVM_INTR_FSHR = 111
-  LLVM_INTR_GET_ACTIVE_LANE_MASK = 112
-  LLVM_INTR_INVARIANT_END = 113
-  LLVM_INTR_INVARIANT_START = 114
-  LLVM_INTR_IS_CONSTANT = 115
-  LLVM_INTR_IS_FPCLASS = 116
-  LLVM_INTR_LIFETIME_END = 117
-  LLVM_INTR_LIFETIME_START = 118
-  LLVM_INTR_LLRINT = 119
-  LLVM_INTR_LLROUND = 120
-  LLVM_INTR_LOG10 = 121
-  LLVM_INTR_LOG2 = 122
-  LLVM_INTR_LOG = 123
-  LLVM_INTR_LRINT = 124
-  LLVM_INTR_LROUND = 125
-  LLVM_INTR_MASKED_LOAD = 126
-  LLVM_INTR_MASKED_STORE = 127
-  LLVM_INTR_MATRIX_COLUMN_MAJOR_LOAD = 128
-  LLVM_INTR_MATRIX_COLUMN_MAJOR_STORE = 129
-  LLVM_INTR_MATRIX_MULTIPLY = 130
-  LLVM_INTR_MATRIX_TRANSPOSE = 131
-  LLVM_INTR_MAXNUM = 132
-  LLVM_INTR_MAXIMUM = 133
-  LLVM_INTR_MEMCPY_INLINE = 134
-  LLVM_INTR_MEMCPY = 135
-  LLVM_INTR_MEMMOVE = 136
-  LLVM_INTR_MEMSET = 137
-  LLVM_INTR_MINNUM = 138
-  LLVM_INTR_MINIMUM = 139
-  LLVM_INTR_NEARBYINT = 140
-  LLVM_INTR_EXPERIMENTAL_NOALIAS_SCOPE_DECL = 141
-  LLVM_INTR_POWI = 142
-  LLVM_INTR_POW = 143
-  LLVM_INTR_PREFETCH = 144
-  LLVM_INTR_PTR_ANNOTATION = 145
-  LLVM_INTR_RINT = 146
-  LLVM_INTR_ROUNDEVEN = 147
-  LLVM_INTR_ROUND = 148
-  LLVM_INTR_SADD_SAT = 149
-  LLVM_INTR_SADD_WITH_OVERFLOW = 150
-  LLVM_INTR_SMAX = 151
-  LLVM_INTR_SMIN = 152
-  LLVM_INTR_SMUL_WITH_OVERFLOW = 153
-  LLVM_INTR_SSA_COPY = 154
-  LLVM_INTR_SSHL_SAT = 155
-  LLVM_INTR_SSUB_SAT = 156
-  LLVM_INTR_SSUB_WITH_OVERFLOW = 157
-  LLVM_INTR_SIN = 158
-  LLVM_INTR_SQRT = 159
-  LLVM_INTR_STACKRESTORE = 160
-  LLVM_INTR_STACKSAVE = 161
-  LLVM_INTR_EXPERIMENTAL_STEPVECTOR = 162
-  LLVM_INTR_THREADLOCAL_ADDRESS = 163
-  LLVM_INTR_TRAP = 164
-  LLVM_INTR_UADD_SAT = 165
-  LLVM_INTR_UADD_WITH_OVERFLOW = 166
-  LLVM_INTR_UBSANTRAP = 167
-  LLVM_INTR_UMAX = 168
-  LLVM_INTR_UMIN = 169
-  LLVM_INTR_UMUL_WITH_OVERFLOW = 170
-  LLVM_INTR_USHL_SAT = 171
-  LLVM_INTR_USUB_SAT = 172
-  LLVM_INTR_USUB_WITH_OVERFLOW = 173
-  LLVM_INTR_VP_ASHR = 174
-  LLVM_INTR_VP_ADD = 175
-  LLVM_INTR_VP_AND = 176
-  LLVM_INTR_VP_FADD = 177
-  LLVM_INTR_VP_FDIV = 178
-  LLVM_INTR_VP_FMULADD = 179
-  LLVM_INTR_VP_FMUL = 180
-  LLVM_INTR_VP_FNEG = 181
-  LLVM_INTR_VP_FPEXT = 182
-  LLVM_INTR_VP_FPTOSI = 183
-  LLVM_INTR_VP_FPTOUI = 184
-  LLVM_INTR_VP_FPTRUNC = 185
-  LLVM_INTR_VP_FREM = 186
-  LLVM_INTR_VP_FSUB = 187
-  LLVM_INTR_VP_FMA = 188
-  LLVM_INTR_VP_INTTOPTR = 189
-  LLVM_INTR_VP_LSHR = 190
-  LLVM_INTR_VP_LOAD = 191
-  LLVM_INTR_VP_MERGE = 192
-  LLVM_INTR_VP_MUL = 193
-  LLVM_INTR_VP_OR = 194
-  LLVM_INTR_VP_PTRTOINT = 195
-  LLVM_INTR_VP_REDUCE_ADD = 196
-  LLVM_INTR_VP_REDUCE_AND = 197
-  LLVM_INTR_VP_REDUCE_FADD = 198
-  LLVM_INTR_VP_REDUCE_FMAX = 199
-  LLVM_INTR_VP_REDUCE_FMIN = 200
-  LLVM_INTR_VP_REDUCE_FMUL = 201
-  LLVM_INTR_VP_REDUCE_MUL = 202
-  LLVM_INTR_VP_REDUCE_OR = 203
-  LLVM_INTR_VP_REDUCE_SMAX = 204
-  LLVM_INTR_VP_REDUCE_SMIN = 205
-  LLVM_INTR_VP_REDUCE_UMAX = 206
-  LLVM_INTR_VP_REDUCE_UMIN = 207
-  LLVM_INTR_VP_REDUCE_XOR = 208
-  LLVM_INTR_VP_SDIV = 209
-  LLVM_INTR_VP_SEXT = 210
-  LLVM_INTR_VP_SITOFP = 211
-  LLVM_INTR_VP_SREM = 212
-  LLVM_INTR_VP_SELECT = 213
-  LLVM_INTR_VP_SHL = 214
-  LLVM_INTR_VP_STORE = 215
-  LLVM_INTR_EXPERIMENTAL_VP_STRIDED_LOAD = 216
-  LLVM_INTR_EXPERIMENTAL_VP_STRIDED_STORE = 217
-  LLVM_INTR_VP_SUB = 218
-  LLVM_INTR_VP_TRUNC = 219
-  LLVM_INTR_VP_UDIV = 220
-  LLVM_INTR_VP_UITOFP = 221
-  LLVM_INTR_VP_UREM = 222
-  LLVM_INTR_VP_XOR = 223
-  LLVM_INTR_VP_ZEXT = 224
-  LLVM_INTR_VACOPY = 225
-  LLVM_INTR_VAEND = 226
-  LLVM_INTR_VASTART = 227
-  LLVM_INTR_VAR_ANNOTATION = 228
-  LLVM_INTR_MASKED_COMPRESSSTORE = 229
-  LLVM_INTR_MASKED_EXPANDLOAD = 230
-  LLVM_INTR_MASKED_GATHER = 231
-  LLVM_INTR_MASKED_SCATTER = 232
-  LLVM_INTR_VECTOR_EXTRACT = 233
-  LLVM_INTR_VECTOR_INSERT = 234
-  LLVM_INTR_VECTOR_REDUCE_ADD = 235
-  LLVM_INTR_VECTOR_REDUCE_AND = 236
-  LLVM_INTR_VECTOR_REDUCE_FADD = 237
-  LLVM_INTR_VECTOR_REDUCE_FMAX = 238
-  LLVM_INTR_VECTOR_REDUCE_FMAXIMUM = 239
-  LLVM_INTR_VECTOR_REDUCE_FMIN = 240
-  LLVM_INTR_VECTOR_REDUCE_FMINIMUM = 241
-  LLVM_INTR_VECTOR_REDUCE_FMUL = 242
-  LLVM_INTR_VECTOR_REDUCE_MUL = 243
-  LLVM_INTR_VECTOR_REDUCE_OR = 244
-  LLVM_INTR_VECTOR_REDUCE_SMAX = 245
-  LLVM_INTR_VECTOR_REDUCE_SMIN = 246
-  LLVM_INTR_VECTOR_REDUCE_UMAX = 247
-  LLVM_INTR_VECTOR_REDUCE_UMIN = 248
-  LLVM_INTR_VECTOR_REDUCE_XOR = 249
-  LLVM_INTR_VSCALE = 250
-  MEMREF_ASSUME_ALIGNMENT = 251
-  MEMREF_ATOMIC_RMW = 252
-  MEMREF_ATOMIC_YIELD = 253
-  MEMREF_COPY = 254
-  MEMREF_GENERIC_ATOMIC_RMW = 255
-  MEMREF_LOAD = 256
-  MEMREF_ALLOC = 257
-  MEMREF_ALLOCA = 258
-  MEMREF_ALLOCA_SCOPE = 259
-  MEMREF_ALLOCA_SCOPE_RETURN = 260
-  MEMREF_CAST = 261
-  MEMREF_COLLAPSE_SHAPE = 262
-  MEMREF_DEALLOC = 263
-  MEMREF_DIM = 264
-  MEMREF_DMA_START = 265
-  MEMREF_DMA_WAIT = 266
-  MEMREF_EXPAND_SHAPE = 267
-  MEMREF_EXTRACT_ALIGNED_POINTER_AS_INDEX = 268
-  MEMREF_EXTRACT_STRIDED_METADATA = 269
-  MEMREF_GET_GLOBAL = 270
-  MEMREF_GLOBAL = 271
-  MEMREF_MEMORY_SPACE_CAST = 272
-  MEMREF_PREFETCH = 273
-  MEMREF_RANK = 274
-  MEMREF_REALLOC = 275
-  MEMREF_REINTERPRET_CAST = 276
-  MEMREF_RESHAPE = 277
-  MEMREF_STORE = 278
-  MEMREF_TRANSPOSE = 279
-  MEMREF_VIEW = 280
-  MEMREF_SUBVIEW = 281
-  ABI_CALL_ARGS = 282
-  ABI_CALL_EXEC = 283
-  ABI_CALL = 284
-  ABI_CALL_RETS = 285
-  ABI_DIRECT = 286
-  ABI_EPILOGUE = 287
-  ABI_FUNC = 288
-  ABI_INDIRECT = 289
-  ABI_PROLOGUE = 290
-  ABI_RET_DIRECT = 291
-  ABI_YIELD = 292
-  LL_ALLOCA = 293
-  LL_ARG_ALLOCA = 294
-  LL_BR = 295
-  LL_CONCAT = 296
-  LL_COND_BR = 297
-  LL_COND_SCOPE_RET = 298
-  LL_EXTRACT = 299
-  LL_INITIALIZE = 300
-  LL_INLINE_SCOPE = 301
-  LL_LOAD = 302
-  LL_FUNC = 303
-  LL_GEP = 304
-  LL_RETURN = 305
-  LL_SCOPE = 306
-  LL_SCOPE_RECURSE = 307
-  LL_SCOPE_RET = 308
-  LL_STORE = 309
-  LL_SUBSCRIPT = 310
-  LL_UNINITIALIZED_VAR = 311
-  HL_ACCESS = 312
-  HL_ASSIGN_FADD = 313
-  HL_FADD = 314
-  HL_ASSIGN_ADD = 315
-  HL_ADD = 316
-  HL_LABELADDR = 317
-  HL_ADDRESSOF = 318
-  HL_ALIGNOF_EXPR = 319
-  HL_ALIGNOF_TYPE = 320
-  HL_ASM = 321
-  HL_ASSIGN = 322
-  HL_ATTRIBUTED_STMT = 323
-  HL_ASSIGN_BIN_ASHR = 324
-  HL_BIN_ASHR = 325
-  HL_ASSIGN_BIN_AND = 326
-  HL_BIN_AND = 327
-  HL_BIN_COMMA = 328
-  HL_BIN_LAND = 329
-  HL_BIN_LOR = 330
-  HL_ASSIGN_BIN_LSHR = 331
-  HL_BIN_LSHR = 332
-  HL_ASSIGN_BIN_OR = 333
-  HL_BIN_OR = 334
-  HL_ASSIGN_BIN_SHL = 335
-  HL_BIN_SHL = 336
-  HL_ASSIGN_BIN_XOR = 337
-  HL_BIN_XOR = 338
-  HL_BINARY_COND = 339
-  HL_BREAK = 340
-  HL_BUILTIN_BITCAST = 341
-  HL_BUILTIN_TYPES_COMPATIBLE_P_TYPE = 342
-  HL_CSTYLE_CAST = 343
-  HL_CALL = 344
-  HL_CASE = 345
-  HL_CHOOSE_EXPR = 346
-  HL_CLASS = 347
-  HL_CMP = 348
-  HL_COMPOUND_LITERAL = 349
-  HL_COND = 350
-  HL_COND_YIELD = 351
-  HL_CONST = 352
-  HL_CONTINUE = 353
-  HL_BASE = 354
-  HL_CXXSTRUCT = 355
-  HL_REF = 356
-  HL_DEFAULT = 357
-  HL_DEREF = 358
-  HL_ASSIGN_FDIV = 359
-  HL_FDIV = 360
-  HL_ASSIGN_SDIV = 361
-  HL_SDIV = 362
-  HL_ASSIGN_UDIV = 363
-  HL_UDIV = 364
-  HL_DO = 365
-  HL_EMPTY_DECL = 366
-  HL_ENUM_CONST = 367
-  HL_ENUM = 368
-  HL_ENUMREF = 369
-  HL_EXPR = 370
-  HL_GNU_EXTENSION = 371
-  HL_FCMP = 372
-  HL_FIELD = 373
-  HL_FILE_SCOPE_ASM = 374
-  HL_FOR = 375
-  HL_FUNC = 376
-  HL_FUNCREF = 377
-  HL_GENERIC_ASOC = 378
-  HL_GENERIC_EXPR = 379
-  HL_GLOBREF = 380
-  HL_GOTO = 381
-  HL_IF = 382
-  HL_IMAG = 383
-  HL_IMPLICIT_CAST = 384
-  HL_INDIRECT_CALL = 385
-  HL_INDIRECT_GOTO = 386
-  HL_INITLIST = 387
-  HL_CONST_INIT = 388
-  HL_LNOT = 389
-  HL_LABEL_DECL = 390
-  HL_LABEL = 391
-  HL_MINUS = 392
-  HL_ASSIGN_FMUL = 393
-  HL_FMUL = 394
-  HL_ASSIGN_MUL = 395
-  HL_MUL = 396
-  HL_NOT = 397
-  HL_NULL = 398
-  HL_OFFSETOF_EXPR = 399
-  HL_OPAQUE_EXPR = 400
-  HL_PLUS = 401
-  HL_POST_DEC = 402
-  HL_POST_INC = 403
-  HL_PRE_DEC = 404
-  HL_PRE_INC = 405
-  HL_PREDEFINED_EXPR = 406
-  HL_PREFERRED_ALIGNOF_EXPR = 407
-  HL_PREFERRED_ALIGNOF_TYPE = 408
-  HL_REAL = 409
-  HL_MEMBER = 410
-  HL_ASSIGN_FREM = 411
-  HL_FREM = 412
-  HL_ASSIGN_SREM = 413
-  HL_SREM = 414
-  HL_ASSIGN_UREM = 415
-  HL_UREM = 416
-  HL_RETURN = 417
-  HL_SIZEOF_EXPR = 418
-  HL_SIZEOF_TYPE = 419
-  HL_STATIC_ASSERT = 420
-  HL_STMT_EXPR = 421
-  HL_STRUCT = 422
-  HL_ASSIGN_FSUB = 423
-  HL_FSUB = 424
-  HL_ASSIGN_SUB = 425
-  HL_SUB = 426
-  HL_SUBSCRIPT = 427
-  HL_SWITCH = 428
-  HL_THIS = 429
-  HL_TRANSLATION_UNIT = 430
-  HL_ALIAS = 431
-  HL_TYPE = 432
-  HL_TYPEDEF = 433
-  HL_TYPEOF_EXPR = 434
-  HL_TYPE_YIELD = 435
-  HL_UNION = 436
-  HL_UNREACHABLE = 437
-  HL_VA_ARG_EXPR = 438
-  HL_VALUE_YIELD = 439
-  HL_VAR = 440
-  HL_WHILE = 441
-  CORE_BIN_LAND = 442
-  CORE_BIN_LOR = 443
-  CORE_IMPLICIT_RETURN = 444
-  CORE_LAZY_OP = 445
-  CORE_MODULE = 446
-  CORE_SCOPE = 447
-  CORE_SELECT = 448
-  UNSUP_DECL = 449
-  UNSUP_STMT = 450
-
-class BasicBlockOrder(IntEnum):
-  PRE_ORDER = 0
-  POST_ORDER = 1
-
-class TypeKind(IntEnum):
-  UNKNOWN = 0
-  BUILTIN_SHAPED = 1
-  BUILTIN_FLOAT = 2
-  BUILTIN_COMPLEX = 3
-  BUILTIN_FLOAT8_E5_M2 = 4
-  BUILTIN_FLOAT8_E4_M3_FN = 5
-  BUILTIN_FLOAT8_E5_M2_FNUZ = 6
-  BUILTIN_FLOAT8_E4_M3_FNUZ = 7
-  BUILTIN_FLOAT8_E4_M3_B11_FNUZ = 8
-  BUILTIN_B_FLOAT16 = 9
-  BUILTIN_FLOAT16 = 10
-  BUILTIN_FLOAT_TF32 = 11
-  BUILTIN_FLOAT32 = 12
-  BUILTIN_FLOAT64 = 13
-  BUILTIN_FLOAT80 = 14
-  BUILTIN_FLOAT128 = 15
-  BUILTIN_FUNCTION = 16
-  BUILTIN_INDEX = 17
-  BUILTIN_INTEGER = 18
-  BUILTIN_MEM_REF = 19
-  BUILTIN_NONE = 20
-  BUILTIN_OPAQUE = 21
-  BUILTIN_RANKED_TENSOR = 22
-  BUILTIN_TUPLE = 23
-  BUILTIN_UNRANKED_MEM_REF = 24
-  BUILTIN_UNRANKED_TENSOR = 25
-  BUILTIN_VECTOR = 26
-  LLVM_ARRAY = 27
-  LLVM_FUNCTION = 28
-  LLVM_POINTER = 29
-  LLVM_FIXED_VECTOR = 30
-  LLVM_SCALABLE_VECTOR = 31
-  LLVM_TARGET_EXT = 32
-  HL_RECORD = 33
-  HL_ENUM = 34
-  HL_TYPEDEF = 35
-  HL_ELABORATED = 36
-  HL_LABEL = 37
-  HL_PAREN = 38
-  HL_L_VALUE = 39
-  HL_R_VALUE = 40
-  HL_VOID = 41
-  HL_BOOL = 42
-  HL_CHAR = 43
-  HL_SHORT = 44
-  HL_INT = 45
-  HL_LONG = 46
-  HL_LONG_LONG = 47
-  HL_INT128 = 48
-  HL_HALF = 49
-  HL_B_FLOAT16 = 50
-  HL_FLOAT = 51
-  HL_DOUBLE = 52
-  HL_LONG_DOUBLE = 53
-  HL_FLOAT128 = 54
-  HL_COMPLEX = 55
-  HL_POINTER = 56
-  HL_ARRAY = 57
-  HL_VECTOR = 58
-  HL_DECAYED = 59
-  HL_ATTRIBUTED = 60
-  HL_ADJUSTED = 61
-  HL_REFERENCE = 62
-  HL_TYPE_OF_EXPR = 63
-  HL_TYPE_OF_TYPE = 64
-  HL_AUTO = 65
-  HL_ATOMIC = 66
-  CORE_FUNCTION = 67
-  UNSUP_UNSUPPORTED = 68
-
-class Attribute(object):
-  kind: multiplier.ir.AttributeKind
-
-class Value(object):
-  kind: multiplier.ir.ValueKind
-  type: multiplier.ir.Type
-  uses: Iterable[multiplier.ir.Operand]
-
-class Argument(multiplier.ir.Value):
-  index: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.ValueKind:
-    ...
-
-  @staticmethod
-  def FROM(val: multiplier.ir.Value) -> Optional[multiplier.ir.Argument]:
-    ...
-
-class Result(multiplier.ir.Value):
-  operation: multiplier.ir.Operation
-  index: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.ValueKind:
-    ...
-
-  @staticmethod
-  def of(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.Result]:
-    ...
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Value) -> Optional[multiplier.ir.Result]:
-    ...
-
-class Block(object):
-  num_arguments: int
-  arguments: Iterable[multiplier.ir.Argument]
-  operations: Iterable[multiplier.ir.Operation]
-  reverse_operations: Iterable[multiplier.ir.Operation]
-  uses: Iterable[multiplier.ir.Label]
-  terminator: multiplier.ir.Operation
-
-  @overload
-  @staticmethod
-  def containing(arg_0: multiplier.ir.Argument) -> multiplier.ir.Block:
-    ...
-
-  @overload
-  @staticmethod
-  def containing(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.Block]:
-    ...
-
-  def nth_argument(self, arg_0: int) -> Optional[multiplier.ir.Argument]:
-    ...
-
-class Label(object):
-  operation: multiplier.ir.Operation
-  block: multiplier.ir.Block
-  index: int
-
-class Operation(multiplier.Entity):
-  kind_name: str
-  kind: multiplier.ir.OperationKind
-  num_operands: int
-  operands: Iterable[multiplier.ir.Operand]
-  num_results: int
-  results: Iterable[multiplier.ir.Result]
-  num_regions: int
-  regions: Iterable[multiplier.ir.Region]
-  only_region: Optional[multiplier.ir.Region]
-  only_region_blocks: Iterable[multiplier.ir.Block]
-  uses: Iterable[multiplier.ir.Operand]
-  previous: Optional[multiplier.ir.Operation]
-  next: Optional[multiplier.ir.Operation]
-  is_terminator: bool
-  defined_symbol: Optional[multiplier.ir.Symbol]
-
-  @staticmethod
-  def classify(arg_0: str) -> multiplier.ir.OperationKind:
-    ...
-
-  @overload
-  @staticmethod
-  def producing(val: multiplier.ir.Result) -> multiplier.ir.Operation:
-    ...
-
-  @overload
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.Operation]:
-    ...
-
-  @overload
-  @staticmethod
-  def containing(arg_0: multiplier.ir.Region) -> multiplier.ir.Operation:
-    ...
-
-  @overload
-  @staticmethod
-  def containing(arg_0: multiplier.ir.Block) -> multiplier.ir.Operation:
-    ...
-
-  @overload
-  @staticmethod
-  def first_from(that: multiplier.ast.Decl) -> Optional[multiplier.ir.Operation]:
-    ...
-
-  @overload
-  @staticmethod
-  def first_from(that: multiplier.ast.Decl, arg_1: multiplier.ir.OperationKind) -> Optional[multiplier.ir.Operation]:
-    ...
-
-  @overload
-  @staticmethod
-  def first_from(that: multiplier.ast.Stmt) -> Optional[multiplier.ir.Operation]:
-    ...
-
-  @overload
-  @staticmethod
-  def first_from(that: multiplier.ast.Stmt, arg_1: multiplier.ir.OperationKind) -> Optional[multiplier.ir.Operation]:
-    ...
-
-  @overload
-  @staticmethod
-  def all_from(that: multiplier.ast.Decl) -> Iterable[multiplier.ir.Operation]:
-    ...
-
-  @overload
-  @staticmethod
-  def all_from(that: multiplier.ast.Stmt) -> Iterable[multiplier.ir.Operation]:
-    ...
-
-  @staticmethod
-  def defining(symbol: multiplier.ir.Symbol) -> multiplier.ir.Operation:
-    ...
-
-  def nth_operand(self, arg_0: int) -> Optional[multiplier.ir.Operand]:
-    ...
-
-  def nth_result(self, arg_0: int) -> Optional[multiplier.ir.Result]:
-    ...
-
-  def nth_region(self, arg_0: int) -> Optional[multiplier.ir.Region]:
-    ...
-
-class Operand(object):
-  operation: multiplier.ir.Operation
-  index: int
-  value: multiplier.ir.Value
-
-class Symbol(object):
-  operation: multiplier.ir.Operation
-  name: str
-  references: Iterable[multiplier.ir.Operation]
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.Symbol]:
-    ...
-
-class Region(object):
-  num_blocks: int
-  blocks: Iterable[multiplier.ir.Block]
-  reverse_blocks: Iterable[multiplier.ir.Block]
-  entry_block: multiplier.ir.Block
-  num_entry_block_arguments: int
-  entry_block_arguments: Iterable[multiplier.ir.Argument]
-
-  @overload
-  @staticmethod
-  def containing(arg_0: multiplier.ir.Block) -> multiplier.ir.Region:
-    ...
-
-  @overload
-  @staticmethod
-  def containing(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.Region]:
-    ...
-
-  def nth_block(self, arg_0: int) -> Optional[multiplier.ir.Block]:
-    ...
-
-  def nth_entry_block_argument(self, arg_0: int) -> Optional[multiplier.ir.Argument]:
-    ...
-
-class Type(object):
-  kind: multiplier.ir.TypeKind
diff --git a/bindings/Python/multiplier-stubs/ir/abi/__init__.py b/bindings/Python/multiplier-stubs/ir/abi/__init__.py
deleted file mode 100644
index f15877da3..000000000
--- a/bindings/Python/multiplier-stubs/ir/abi/__init__.py
+++ /dev/null
@@ -1,219 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class Operation(multiplier.ir.Operation):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.Operation]:
-    ...
-
-class CallArgsOp(multiplier.ir.abi.Operation):
-  results: Iterable[multiplier.ir.Result]
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.CallArgsOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.CallArgsOp]:
-    ...
-
-class CallExecutionOp(multiplier.ir.abi.Operation):
-  arguments: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-  body: multiplier.ir.Region
-  arg_operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.CallExecutionOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.CallExecutionOp]:
-    ...
-
-class CallOp(multiplier.ir.abi.Operation):
-  arguments: Iterable[multiplier.ir.Operand]
-  results: Iterable[multiplier.ir.Result]
-  callee: str
-  arg_operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.CallOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.CallOp]:
-    ...
-
-class CallRetsOp(multiplier.ir.abi.Operation):
-  results: Iterable[multiplier.ir.Result]
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.CallRetsOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.CallRetsOp]:
-    ...
-
-class DirectOp(multiplier.ir.abi.Operation):
-  value: Iterable[multiplier.ir.Operand]
-  result: Iterable[multiplier.ir.Result]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.DirectOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.DirectOp]:
-    ...
-
-class EpilogueOp(multiplier.ir.abi.Operation):
-  results: Iterable[multiplier.ir.Result]
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.EpilogueOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.EpilogueOp]:
-    ...
-
-class FuncOp(multiplier.ir.abi.Operation):
-  body: Optional[multiplier.ir.Region]
-  name: str
-  function_type: multiplier.ir.Type
-  visibility: Optional[str]
-  is_var_arg: bool
-  callable_results: Iterable[multiplier.ir.Type]
-  argument_types: Iterable[multiplier.ir.Type]
-  result_types: Iterable[multiplier.ir.Type]
-  is_declaration: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.FuncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.FuncOp]:
-    ...
-
-class IndirectOp(multiplier.ir.abi.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.IndirectOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.IndirectOp]:
-    ...
-
-class PrologueOp(multiplier.ir.abi.Operation):
-  results: Iterable[multiplier.ir.Result]
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.PrologueOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.PrologueOp]:
-    ...
-
-class RetDirectOp(multiplier.ir.abi.Operation):
-  value: multiplier.ir.Value
-  result: Iterable[multiplier.ir.Result]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.RetDirectOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.RetDirectOp]:
-    ...
-
-class YieldOp(multiplier.ir.abi.Operation):
-  values: Iterable[multiplier.ir.Operand]
-  result: Iterable[multiplier.ir.Result]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.abi.YieldOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.abi.YieldOp]:
-    ...
diff --git a/bindings/Python/multiplier-stubs/ir/builtin/__init__.py b/bindings/Python/multiplier-stubs/ir/builtin/__init__.py
deleted file mode 100644
index 81cd58849..000000000
--- a/bindings/Python/multiplier-stubs/ir/builtin/__init__.py
+++ /dev/null
@@ -1,618 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class Attribute(multiplier.ir.Attribute):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.Attribute]:
-    ...
-
-class TypedAttr(multiplier.ir.builtin.Attribute):
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.TypedAttr]:
-    ...
-
-class ElementsAttr(multiplier.ir.builtin.Attribute):
-  is_splat: bool
-  num_elements: int
-  size: int
-  empty: bool
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.ElementsAttr]:
-    ...
-
-class AffineMapAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.AffineMapAttr]:
-    ...
-
-class ArrayAttr(multiplier.ir.builtin.Attribute):
-  size: int
-  empty: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.ArrayAttr]:
-    ...
-
-class DenseArrayAttr(multiplier.ir.builtin.Attribute):
-  size: int
-  empty: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.DenseArrayAttr]:
-    ...
-
-class DenseIntOrFPElementsAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.DenseIntOrFPElementsAttr]:
-    ...
-
-class DenseStringElementsAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.DenseStringElementsAttr]:
-    ...
-
-class DenseResourceElementsAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.DenseResourceElementsAttr]:
-    ...
-
-class DictionaryAttr(multiplier.ir.builtin.Attribute):
-  empty: bool
-  size: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.DictionaryAttr]:
-    ...
-
-class FloatAttr(multiplier.ir.builtin.Attribute):
-  value_as_double: float
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.FloatAttr]:
-    ...
-
-class IntegerAttr(multiplier.ir.builtin.Attribute):
-  integer_value: int
-  signed_integer_value: int
-  unsigned_integer_value: int
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.IntegerAttr]:
-    ...
-
-class IntegerSetAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.IntegerSetAttr]:
-    ...
-
-class OpaqueAttr(multiplier.ir.builtin.Attribute):
-  attr_data: str
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.OpaqueAttr]:
-    ...
-
-class SparseElementsAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.SparseElementsAttr]:
-    ...
-
-class StridedLayoutAttr(multiplier.ir.builtin.Attribute):
-  offset: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.StridedLayoutAttr]:
-    ...
-
-class StringAttr(multiplier.ir.builtin.Attribute):
-  str: str
-  size: int
-  empty: bool
-  value: str
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.StringAttr]:
-    ...
-
-class SymbolRefAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.SymbolRefAttr]:
-    ...
-
-class TypeAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.TypeAttr]:
-    ...
-
-class UnitAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.UnitAttr]:
-    ...
-
-class BoolAttr(multiplier.ir.builtin.Attribute):
-  value: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.BoolAttr]:
-    ...
-
-class FlatSymbolRefAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.FlatSymbolRefAttr]:
-    ...
-
-class DenseIntElementsAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.DenseIntElementsAttr]:
-    ...
-
-class DataLayoutSpecAttr(multiplier.ir.builtin.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.builtin.DataLayoutSpecAttr]:
-    ...
-
-class Operation(multiplier.ir.Operation):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.builtin.Operation]:
-    ...
-
-class ModuleOp(multiplier.ir.builtin.Operation):
-  body_region: multiplier.ir.Region
-  name: Optional[str]
-  visibility: Optional[str]
-  is_optional_symbol: bool
-  default_dialect: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.builtin.ModuleOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.builtin.ModuleOp]:
-    ...
-
-class UnrealizedConversionCastOp(multiplier.ir.builtin.Operation):
-  inputs: Iterable[multiplier.ir.Operand]
-  outputs: Iterable[multiplier.ir.Result]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.builtin.UnrealizedConversionCastOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.builtin.UnrealizedConversionCastOp]:
-    ...
-
-class Type(multiplier.ir.Type):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Type]:
-    ...
-
-class ShapedType(multiplier.ir.builtin.Type):
-  element_type: multiplier.ir.Type
-  has_rank: bool
-  element_type_bit_width: int
-  rank: int
-  num_elements: int
-  has_static_shape: bool
-  num_dynamic_dims: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.ShapedType]:
-    ...
-
-class FloatType(multiplier.ir.builtin.Type):
-  width: int
-  fp_mantissa_width: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.FloatType]:
-    ...
-
-class ComplexType(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.ComplexType]:
-    ...
-
-class Float8E5M2Type(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float8E5M2Type]:
-    ...
-
-class Float8E4M3FNType(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float8E4M3FNType]:
-    ...
-
-class Float8E5M2FNUZType(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float8E5M2FNUZType]:
-    ...
-
-class Float8E4M3FNUZType(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float8E4M3FNUZType]:
-    ...
-
-class Float8E4M3B11FNUZType(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float8E4M3B11FNUZType]:
-    ...
-
-class BFloat16Type(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.BFloat16Type]:
-    ...
-
-class Float16Type(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float16Type]:
-    ...
-
-class FloatTF32Type(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.FloatTF32Type]:
-    ...
-
-class Float32Type(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float32Type]:
-    ...
-
-class Float64Type(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float64Type]:
-    ...
-
-class Float80Type(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float80Type]:
-    ...
-
-class Float128Type(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.Float128Type]:
-    ...
-
-class FunctionType(multiplier.ir.builtin.Type):
-  num_inputs: int
-  num_results: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.FunctionType]:
-    ...
-
-class IndexType(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.IndexType]:
-    ...
-
-class IntegerType(multiplier.ir.builtin.Type):
-  is_signless: bool
-  is_signed: bool
-  is_unsigned: bool
-  width: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.IntegerType]:
-    ...
-
-class MemRefType(multiplier.ir.builtin.Type):
-  memory_space_as_int: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.MemRefType]:
-    ...
-
-class NoneType(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.NoneType]:
-    ...
-
-class OpaqueType(multiplier.ir.builtin.Type):
-  type_data: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.OpaqueType]:
-    ...
-
-class RankedTensorType(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.RankedTensorType]:
-    ...
-
-class TupleType(multiplier.ir.builtin.Type):
-  size: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.TupleType]:
-    ...
-
-class UnrankedMemRefType(multiplier.ir.builtin.Type):
-  memory_space_as_int: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.UnrankedMemRefType]:
-    ...
-
-class UnrankedTensorType(multiplier.ir.builtin.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.UnrankedTensorType]:
-    ...
-
-class VectorType(multiplier.ir.builtin.Type):
-  is_scalable: bool
-  all_dims_scalable: bool
-  has_rank: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.builtin.VectorType]:
-    ...
diff --git a/bindings/Python/multiplier-stubs/ir/core/__init__.py b/bindings/Python/multiplier-stubs/ir/core/__init__.py
deleted file mode 100644
index 89e21a072..000000000
--- a/bindings/Python/multiplier-stubs/ir/core/__init__.py
+++ /dev/null
@@ -1,241 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class Attribute(multiplier.ir.Attribute):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Attribute) -> Optional[multiplier.ir.core.Attribute]:
-    ...
-
-class BooleanAttr(multiplier.ir.core.Attribute):
-  type: multiplier.ir.Type
-  value: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.core.BooleanAttr]:
-    ...
-
-class IntegerAttr(multiplier.ir.core.Attribute):
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.core.IntegerAttr]:
-    ...
-
-class FloatAttr(multiplier.ir.core.Attribute):
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.core.FloatAttr]:
-    ...
-
-class VoidAttr(multiplier.ir.core.Attribute):
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.core.VoidAttr]:
-    ...
-
-class SourceLanguageAttr(multiplier.ir.core.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.core.SourceLanguageAttr]:
-    ...
-
-class GlobalLinkageKindAttr(multiplier.ir.core.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.core.GlobalLinkageKindAttr]:
-    ...
-
-class Operation(multiplier.ir.Operation):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.core.Operation]:
-    ...
-
-class BinLAndOp(multiplier.ir.core.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.core.BinLAndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.core.BinLAndOp]:
-    ...
-
-class BinLOrOp(multiplier.ir.core.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.core.BinLOrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.core.BinLOrOp]:
-    ...
-
-class ImplicitReturnOp(multiplier.ir.core.Operation):
-  result: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.core.ImplicitReturnOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.core.ImplicitReturnOp]:
-    ...
-
-class LazyOp(multiplier.ir.core.Operation):
-  result: multiplier.ir.Value
-  lazy: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.core.LazyOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.core.LazyOp]:
-    ...
-
-class ModuleOp(multiplier.ir.core.Operation):
-  body: multiplier.ir.Region
-  name: Optional[str]
-  is_optional_symbol: bool
-  default_dialect: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.core.ModuleOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.core.ModuleOp]:
-    ...
-
-class ScopeOp(multiplier.ir.core.Operation):
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.core.ScopeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.core.ScopeOp]:
-    ...
-
-class SelectOp(multiplier.ir.core.Operation):
-  cond: multiplier.ir.Value
-  then_region: multiplier.ir.Value
-  else_region: multiplier.ir.Value
-  results: Iterable[multiplier.ir.Result]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.core.SelectOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.core.SelectOp]:
-    ...
-
-class Type(multiplier.ir.Type):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Type) -> Optional[multiplier.ir.core.Type]:
-    ...
-
-class FunctionType(multiplier.ir.core.Type):
-  is_var_arg: bool
-  num_inputs: int
-  num_results: int
-  inputs: Iterable[multiplier.ir.Type]
-  results: Iterable[multiplier.ir.Type]
-  var_arg: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.core.FunctionType]:
-    ...
diff --git a/bindings/Python/multiplier-stubs/ir/highlevel/__init__.py b/bindings/Python/multiplier-stubs/ir/highlevel/__init__.py
deleted file mode 100644
index d79798e46..000000000
--- a/bindings/Python/multiplier-stubs/ir/highlevel/__init__.py
+++ /dev/null
@@ -1,3027 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class Attribute(multiplier.ir.Attribute):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.Attribute]:
-    ...
-
-class AnnotationAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AnnotationAttr]:
-    ...
-
-class FormatAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.FormatAttr]:
-    ...
-
-class SectionAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.SectionAttr]:
-    ...
-
-class AliasAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AliasAttr]:
-    ...
-
-class ErrorAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.ErrorAttr]:
-    ...
-
-class CountedByAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.CountedByAttr]:
-    ...
-
-class CleanupAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.CleanupAttr]:
-    ...
-
-class AlignedAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AlignedAttr]:
-    ...
-
-class AlwaysInlineAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AlwaysInlineAttr]:
-    ...
-
-class NoInlineAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.NoInlineAttr]:
-    ...
-
-class ConstAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.ConstAttr]:
-    ...
-
-class LoaderUninitializedAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.LoaderUninitializedAttr]:
-    ...
-
-class NoInstrumentFunctionAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.NoInstrumentFunctionAttr]:
-    ...
-
-class PackedAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.PackedAttr]:
-    ...
-
-class PureAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.PureAttr]:
-    ...
-
-class WarnUnusedResultAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.WarnUnusedResultAttr]:
-    ...
-
-class RestrictAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.RestrictAttr]:
-    ...
-
-class NoThrowAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.NoThrowAttr]:
-    ...
-
-class NonNullAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.NonNullAttr]:
-    ...
-
-class LeafAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.LeafAttr]:
-    ...
-
-class ColdAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.ColdAttr]:
-    ...
-
-class TransparentUnionAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.TransparentUnionAttr]:
-    ...
-
-class ReturnsTwiceAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.ReturnsTwiceAttr]:
-    ...
-
-class MayAliasAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.MayAliasAttr]:
-    ...
-
-class UnusedAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.UnusedAttr]:
-    ...
-
-class UsedAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.UsedAttr]:
-    ...
-
-class GNUInlineAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.GNUInlineAttr]:
-    ...
-
-class NoCfCheckAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.NoCfCheckAttr]:
-    ...
-
-class AvailableOnlyInDefaultEvalMethodAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AvailableOnlyInDefaultEvalMethodAttr]:
-    ...
-
-class AvailabilityAttrAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AvailabilityAttrAttr]:
-    ...
-
-class FallthroughAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.FallthroughAttr]:
-    ...
-
-class NoProfileInstrumentFunctionAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.NoProfileInstrumentFunctionAttr]:
-    ...
-
-class AsmLabelAttr(multiplier.ir.highlevel.Attribute):
-  is_literal: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AsmLabelAttr]:
-    ...
-
-class ModeAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.ModeAttr]:
-    ...
-
-class BuiltinAttr(multiplier.ir.highlevel.Attribute):
-  id: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.BuiltinAttr]:
-    ...
-
-class AllocAlignAttr(multiplier.ir.highlevel.Attribute):
-  alignment: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AllocAlignAttr]:
-    ...
-
-class AllocSizeAttr(multiplier.ir.highlevel.Attribute):
-  size_arg_pos: int
-  num_arg_pos: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AllocSizeAttr]:
-    ...
-
-class DeprecatedAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.DeprecatedAttr]:
-    ...
-
-class MaxFieldAlignmentAttr(multiplier.ir.highlevel.Attribute):
-  alignment: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.MaxFieldAlignmentAttr]:
-    ...
-
-class VisibilityAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.VisibilityAttr]:
-    ...
-
-class AssumeAlignedAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.AssumeAlignedAttr]:
-    ...
-
-class CVQualifiersAttr(multiplier.ir.highlevel.Attribute):
-  is_const: bool
-  is_volatile: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.CVQualifiersAttr]:
-    ...
-
-class UCVQualifiersAttr(multiplier.ir.highlevel.Attribute):
-  is_unsigned: bool
-  is_const: bool
-  is_volatile: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.UCVQualifiersAttr]:
-    ...
-
-class CVRQualifiersAttr(multiplier.ir.highlevel.Attribute):
-  is_const: bool
-  is_volatile: bool
-  is_restrict: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.CVRQualifiersAttr]:
-    ...
-
-class OffsetOfNodeAttr(multiplier.ir.highlevel.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.highlevel.OffsetOfNodeAttr]:
-    ...
-
-class Operation(multiplier.ir.Operation):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.Operation]:
-    ...
-
-class RefOp(multiplier.ir.highlevel.Operation):
-  referenced_symbol: Optional[multiplier.ir.Symbol]
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.RefOp]:
-    ...
-
-class DeclRefOp(multiplier.ir.highlevel.RefOp):
-  declaration: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DeclRefOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DeclRefOp]:
-    ...
-
-class EnumRefOp(multiplier.ir.highlevel.RefOp):
-  result: multiplier.ir.Value
-  value: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.EnumRefOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.EnumRefOp]:
-    ...
-
-class FuncRefOp(multiplier.ir.highlevel.RefOp):
-  result: multiplier.ir.Value
-  function: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.FuncRefOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.FuncRefOp]:
-    ...
-
-class GlobalRefOp(multiplier.ir.highlevel.RefOp):
-  result: multiplier.ir.Value
-  global_: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.GlobalRefOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.GlobalRefOp]:
-    ...
-
-class AccessSpecifierOp(multiplier.ir.highlevel.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AccessSpecifierOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AccessSpecifierOp]:
-    ...
-
-class AddFAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AddFAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AddFAssignOp]:
-    ...
-
-class AddFOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AddFOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AddFOp]:
-    ...
-
-class AddIAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AddIAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AddIAssignOp]:
-    ...
-
-class AddIOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AddIOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AddIOp]:
-    ...
-
-class AddrLabelExprOp(multiplier.ir.highlevel.Operation):
-  label: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AddrLabelExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AddrLabelExprOp]:
-    ...
-
-class AddressOfOp(multiplier.ir.highlevel.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AddressOfOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AddressOfOp]:
-    ...
-
-class AlignOfExprOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  expression: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AlignOfExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AlignOfExprOp]:
-    ...
-
-class AlignOfTypeOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  argument: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AlignOfTypeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AlignOfTypeOp]:
-    ...
-
-class AsmOp(multiplier.ir.highlevel.Operation):
-  asm_outputs: Iterable[multiplier.ir.Operand]
-  asm_inputs: Iterable[multiplier.ir.Operand]
-  labels: Iterable[multiplier.ir.Operand]
-  asm_template: str
-  is_volatile: bool
-  has_goto: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AsmOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AsmOp]:
-    ...
-
-class AssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AssignOp]:
-    ...
-
-class AttributedStmtOp(multiplier.ir.highlevel.Operation):
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.AttributedStmtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.AttributedStmtOp]:
-    ...
-
-class BinAShrAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinAShrAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinAShrAssignOp]:
-    ...
-
-class BinAShrOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinAShrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinAShrOp]:
-    ...
-
-class BinAndAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinAndAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinAndAssignOp]:
-    ...
-
-class BinAndOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinAndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinAndOp]:
-    ...
-
-class BinCommaOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinCommaOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinCommaOp]:
-    ...
-
-class BinLAndOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  left: multiplier.ir.Region
-  right: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinLAndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinLAndOp]:
-    ...
-
-class BinLOrOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  left: multiplier.ir.Region
-  right: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinLOrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinLOrOp]:
-    ...
-
-class BinLShrAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinLShrAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinLShrAssignOp]:
-    ...
-
-class BinLShrOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinLShrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinLShrOp]:
-    ...
-
-class BinOrAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinOrAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinOrAssignOp]:
-    ...
-
-class BinOrOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinOrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinOrOp]:
-    ...
-
-class BinShlAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinShlAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinShlAssignOp]:
-    ...
-
-class BinShlOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinShlOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinShlOp]:
-    ...
-
-class BinXorAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinXorAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinXorAssignOp]:
-    ...
-
-class BinXorOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinXorOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinXorOp]:
-    ...
-
-class BinaryCondOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  common_region: Optional[multiplier.ir.Region]
-  condition_region: multiplier.ir.Region
-  then_region: multiplier.ir.Region
-  else_region: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BinaryCondOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BinaryCondOp]:
-    ...
-
-class BreakOp(multiplier.ir.highlevel.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BreakOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BreakOp]:
-    ...
-
-class BuiltinBitCastOp(multiplier.ir.highlevel.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BuiltinBitCastOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BuiltinBitCastOp]:
-    ...
-
-class BuiltinTypesCompatiblePOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  type1: multiplier.ir.Type
-  type2: multiplier.ir.Type
-  compatible: bool
-  arguments: Iterable[multiplier.ir.Type]
-  value: Optional[bool]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.BuiltinTypesCompatiblePOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.BuiltinTypesCompatiblePOp]:
-    ...
-
-class CStyleCastOp(multiplier.ir.highlevel.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.CStyleCastOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.CStyleCastOp]:
-    ...
-
-class CallOp(multiplier.ir.highlevel.Operation):
-  arg_operands: Iterable[multiplier.ir.Operand]
-  results: Iterable[multiplier.ir.Result]
-  callee: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.CallOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.CallOp]:
-    ...
-
-class CaseOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Region
-  body: Optional[multiplier.ir.Region]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.CaseOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.CaseOp]:
-    ...
-
-class ChooseExprOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  condition_region: multiplier.ir.Region
-  then_region: multiplier.ir.Region
-  else_region: multiplier.ir.Region
-  cond_true: Optional[bool]
-  is_condition_true: Optional[bool]
-  is_condition_dependent: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ChooseExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ChooseExprOp]:
-    ...
-
-class ClassDeclOp(multiplier.ir.highlevel.Operation):
-  bases: multiplier.ir.Region
-  fields: multiplier.ir.Region
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ClassDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ClassDeclOp]:
-    ...
-
-class CmpOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.CmpOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.CmpOp]:
-    ...
-
-class CompoundLiteralOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  initializer: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.CompoundLiteralOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.CompoundLiteralOp]:
-    ...
-
-class CondOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  condition_region: multiplier.ir.Region
-  then_region: multiplier.ir.Region
-  else_region: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.CondOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.CondOp]:
-    ...
-
-class CondYieldOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.CondYieldOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.CondYieldOp]:
-    ...
-
-class ConstantOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ConstantOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ConstantOp]:
-    ...
-
-class ContinueOp(multiplier.ir.highlevel.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ContinueOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ContinueOp]:
-    ...
-
-class CxxBaseSpecifierOp(multiplier.ir.highlevel.Operation):
-  type: multiplier.ir.Type
-  is_virtual: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.CxxBaseSpecifierOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.CxxBaseSpecifierOp]:
-    ...
-
-class CxxStructDeclOp(multiplier.ir.highlevel.Operation):
-  bases: multiplier.ir.Region
-  fields: multiplier.ir.Region
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.CxxStructDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.CxxStructDeclOp]:
-    ...
-
-class DefaultOp(multiplier.ir.highlevel.Operation):
-  body: Optional[multiplier.ir.Region]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DefaultOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DefaultOp]:
-    ...
-
-class DerefOp(multiplier.ir.highlevel.Operation):
-  addr: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DerefOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DerefOp]:
-    ...
-
-class DivFAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DivFAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DivFAssignOp]:
-    ...
-
-class DivFOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DivFOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DivFOp]:
-    ...
-
-class DivSAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DivSAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DivSAssignOp]:
-    ...
-
-class DivSOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DivSOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DivSOp]:
-    ...
-
-class DivUAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DivUAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DivUAssignOp]:
-    ...
-
-class DivUOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DivUOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DivUOp]:
-    ...
-
-class DoOp(multiplier.ir.highlevel.Operation):
-  body_region: multiplier.ir.Region
-  condition_region: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.DoOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.DoOp]:
-    ...
-
-class EmptyDeclOp(multiplier.ir.highlevel.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.EmptyDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.EmptyDeclOp]:
-    ...
-
-class EnumConstantOp(multiplier.ir.highlevel.Operation):
-  initializer: multiplier.ir.Region
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.EnumConstantOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.EnumConstantOp]:
-    ...
-
-class EnumDeclOp(multiplier.ir.highlevel.Operation):
-  constants: multiplier.ir.Region
-  name: str
-  type: Optional[multiplier.ir.Type]
-  is_complete: bool
-  constants_block: multiplier.ir.Block
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.EnumDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.EnumDeclOp]:
-    ...
-
-class ExprOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  nested_expression: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ExprOp]:
-    ...
-
-class ExtensionOp(multiplier.ir.highlevel.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ExtensionOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ExtensionOp]:
-    ...
-
-class FCmpOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.FCmpOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.FCmpOp]:
-    ...
-
-class FieldDeclOp(multiplier.ir.highlevel.Operation):
-  name: str
-  type: multiplier.ir.Type
-  bits: Optional[int]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.FieldDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.FieldDeclOp]:
-    ...
-
-class FileScopeAsmOp(multiplier.ir.highlevel.Operation):
-  assembly: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.FileScopeAsmOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.FileScopeAsmOp]:
-    ...
-
-class ForOp(multiplier.ir.highlevel.Operation):
-  condition_region: multiplier.ir.Region
-  incr_region: Optional[multiplier.ir.Region]
-  body_region: Optional[multiplier.ir.Region]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ForOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ForOp]:
-    ...
-
-class FuncOp(multiplier.ir.highlevel.Operation):
-  body: Optional[multiplier.ir.Region]
-  name: str
-  function_type: multiplier.ir.Type
-  visibility: Optional[str]
-  is_var_arg: bool
-  callable_results: Iterable[multiplier.ir.Type]
-  argument_types: Iterable[multiplier.ir.Type]
-  result_types: Iterable[multiplier.ir.Type]
-  is_declaration: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.FuncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.FuncOp]:
-    ...
-
-class GenericAssocExprOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  body: multiplier.ir.Region
-  match_type: Optional[multiplier.ir.Type]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.GenericAssocExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.GenericAssocExprOp]:
-    ...
-
-class GenericSelectionExprOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  control: multiplier.ir.Region
-  body: multiplier.ir.Region
-  control_type: Optional[multiplier.ir.Type]
-  is_expression_predicate: bool
-  is_type_predicate: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.GenericSelectionExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.GenericSelectionExprOp]:
-    ...
-
-class GotoStmtOp(multiplier.ir.highlevel.Operation):
-  label: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.GotoStmtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.GotoStmtOp]:
-    ...
-
-class IfOp(multiplier.ir.highlevel.Operation):
-  condition_region: multiplier.ir.Region
-  then_region: multiplier.ir.Region
-  else_region: Optional[multiplier.ir.Region]
-  has_else: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.IfOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.IfOp]:
-    ...
-
-class ImagOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ImagOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ImagOp]:
-    ...
-
-class ImplicitCastOp(multiplier.ir.highlevel.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ImplicitCastOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ImplicitCastOp]:
-    ...
-
-class IndirectCallOp(multiplier.ir.highlevel.Operation):
-  callee: multiplier.ir.Value
-  arg_operands: Iterable[multiplier.ir.Operand]
-  results: Iterable[multiplier.ir.Result]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.IndirectCallOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.IndirectCallOp]:
-    ...
-
-class IndirectGotoStmtOp(multiplier.ir.highlevel.Operation):
-  target: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.IndirectGotoStmtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.IndirectGotoStmtOp]:
-    ...
-
-class InitListExprOp(multiplier.ir.highlevel.Operation):
-  elements: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.InitListExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.InitListExprOp]:
-    ...
-
-class InitializedConstantOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  initializer: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.InitializedConstantOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.InitializedConstantOp]:
-    ...
-
-class LNotOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.LNotOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.LNotOp]:
-    ...
-
-class LabelDeclOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.LabelDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.LabelDeclOp]:
-    ...
-
-class LabelStmtOp(multiplier.ir.highlevel.Operation):
-  label: multiplier.ir.Value
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.LabelStmtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.LabelStmtOp]:
-    ...
-
-class MinusOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.MinusOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.MinusOp]:
-    ...
-
-class MulFAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.MulFAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.MulFAssignOp]:
-    ...
-
-class MulFOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.MulFOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.MulFOp]:
-    ...
-
-class MulIAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.MulIAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.MulIAssignOp]:
-    ...
-
-class MulIOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.MulIOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.MulIOp]:
-    ...
-
-class NotOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.NotOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.NotOp]:
-    ...
-
-class NullStmtOp(multiplier.ir.highlevel.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.NullStmtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.NullStmtOp]:
-    ...
-
-class OffsetOfExprOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  array_index_exprs: Iterable[multiplier.ir.Region]
-  source: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.OffsetOfExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.OffsetOfExprOp]:
-    ...
-
-class OpaqueValueExprOp(multiplier.ir.highlevel.Operation):
-  argument: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.OpaqueValueExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.OpaqueValueExprOp]:
-    ...
-
-class PlusOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.PlusOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.PlusOp]:
-    ...
-
-class PostDecOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.PostDecOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.PostDecOp]:
-    ...
-
-class PostIncOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.PostIncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.PostIncOp]:
-    ...
-
-class PreDecOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.PreDecOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.PreDecOp]:
-    ...
-
-class PreIncOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.PreIncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.PreIncOp]:
-    ...
-
-class PredefinedExprOp(multiplier.ir.highlevel.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.PredefinedExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.PredefinedExprOp]:
-    ...
-
-class PreferredAlignOfExprOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  expression: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.PreferredAlignOfExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.PreferredAlignOfExprOp]:
-    ...
-
-class PreferredAlignOfTypeOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  argument: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.PreferredAlignOfTypeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.PreferredAlignOfTypeOp]:
-    ...
-
-class RealOp(multiplier.ir.highlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.RealOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.RealOp]:
-    ...
-
-class RecordMemberOp(multiplier.ir.highlevel.Operation):
-  record: multiplier.ir.Value
-  element: multiplier.ir.Value
-  field: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.RecordMemberOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.RecordMemberOp]:
-    ...
-
-class RemFAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.RemFAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.RemFAssignOp]:
-    ...
-
-class RemFOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.RemFOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.RemFOp]:
-    ...
-
-class RemSAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.RemSAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.RemSAssignOp]:
-    ...
-
-class RemSOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.RemSOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.RemSOp]:
-    ...
-
-class RemUAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.RemUAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.RemUAssignOp]:
-    ...
-
-class RemUOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.RemUOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.RemUOp]:
-    ...
-
-class ReturnOp(multiplier.ir.highlevel.Operation):
-  result: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ReturnOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ReturnOp]:
-    ...
-
-class SizeOfExprOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  expression: multiplier.ir.Region
-  value: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.SizeOfExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.SizeOfExprOp]:
-    ...
-
-class SizeOfTypeOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  argument: multiplier.ir.Type
-  value: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.SizeOfTypeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.SizeOfTypeOp]:
-    ...
-
-class StaticAssertDeclOp(multiplier.ir.highlevel.Operation):
-  assertion: multiplier.ir.Region
-  message: multiplier.ir.Region
-  failed: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.StaticAssertDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.StaticAssertDeclOp]:
-    ...
-
-class StmtExprOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  nested_statement: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.StmtExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.StmtExprOp]:
-    ...
-
-class StructDeclOp(multiplier.ir.highlevel.Operation):
-  fields: multiplier.ir.Region
-  name: str
-  field_types: Iterable[multiplier.ir.Type]
-  defined_type: multiplier.ir.Type
-  is_complete_definition: bool
-  fields_block: multiplier.ir.Block
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.StructDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.StructDeclOp]:
-    ...
-
-class SubFAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.SubFAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.SubFAssignOp]:
-    ...
-
-class SubFOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.SubFOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.SubFOp]:
-    ...
-
-class SubIAssignOp(multiplier.ir.highlevel.Operation):
-  source: multiplier.ir.Value
-  destination: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.SubIAssignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.SubIAssignOp]:
-    ...
-
-class SubIOp(multiplier.ir.highlevel.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.SubIOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.SubIOp]:
-    ...
-
-class SubscriptOp(multiplier.ir.highlevel.Operation):
-  array: multiplier.ir.Value
-  index: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.SubscriptOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.SubscriptOp]:
-    ...
-
-class SwitchOp(multiplier.ir.highlevel.Operation):
-  condition_region: multiplier.ir.Region
-  cases: Iterable[multiplier.ir.Region]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.SwitchOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.SwitchOp]:
-    ...
-
-class ThisOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ThisOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ThisOp]:
-    ...
-
-class TranslationUnitOp(multiplier.ir.highlevel.Operation):
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.TranslationUnitOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.TranslationUnitOp]:
-    ...
-
-class TypeAliasOp(multiplier.ir.highlevel.Operation):
-  name: str
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.TypeAliasOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.TypeAliasOp]:
-    ...
-
-class TypeDeclOp(multiplier.ir.highlevel.Operation):
-  name: str
-  type: multiplier.ir.Type
-  defined_type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.TypeDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.TypeDeclOp]:
-    ...
-
-class TypeDefOp(multiplier.ir.highlevel.Operation):
-  name: str
-  type: multiplier.ir.Type
-  defined_type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.TypeDefOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.TypeDefOp]:
-    ...
-
-class TypeOfExprOp(multiplier.ir.highlevel.Operation):
-  expression: multiplier.ir.Region
-  name: str
-  type: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.TypeOfExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.TypeOfExprOp]:
-    ...
-
-class TypeYieldOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  yielded: multiplier.ir.Type
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.TypeYieldOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.TypeYieldOp]:
-    ...
-
-class UnionDeclOp(multiplier.ir.highlevel.Operation):
-  fields: multiplier.ir.Region
-  name: str
-  field_types: Iterable[multiplier.ir.Type]
-  defined_type: multiplier.ir.Type
-  is_complete_definition: bool
-  fields_block: multiplier.ir.Block
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.UnionDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.UnionDeclOp]:
-    ...
-
-class UnreachableOp(multiplier.ir.highlevel.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.UnreachableOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.UnreachableOp]:
-    ...
-
-class VAArgExprOp(multiplier.ir.highlevel.Operation):
-  argument_list: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.VAArgExprOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.VAArgExprOp]:
-    ...
-
-class ValueYieldOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.ValueYieldOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.ValueYieldOp]:
-    ...
-
-class VarDeclOp(multiplier.ir.highlevel.Operation):
-  result: multiplier.ir.Value
-  initializer: Optional[multiplier.ir.Region]
-  allocation_size: Optional[multiplier.ir.Region]
-  name: str
-  has_local_storage: bool
-  is_local_variable_declaration: bool
-  is_static_local_variable_declaration: bool
-  has_external_storage: bool
-  has_global_storage: bool
-  is_static_data_member: bool
-  is_in_file_context: bool
-  is_in_function_or_method_context: bool
-  is_in_record_context: bool
-  is_file_variable_declaration: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.VarDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.VarDeclOp]:
-    ...
-
-class WhileOp(multiplier.ir.highlevel.Operation):
-  condition_region: multiplier.ir.Region
-  body_region: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.highlevel.WhileOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.highlevel.WhileOp]:
-    ...
-
-class Type(multiplier.ir.Type):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.Type]:
-    ...
-
-class RecordType(multiplier.ir.highlevel.Type):
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.RecordType]:
-    ...
-
-class EnumType(multiplier.ir.highlevel.Type):
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.EnumType]:
-    ...
-
-class TypedefType(multiplier.ir.highlevel.Type):
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.TypedefType]:
-    ...
-
-class ElaboratedType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.ElaboratedType]:
-    ...
-
-class LabelType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.LabelType]:
-    ...
-
-class ParenType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.ParenType]:
-    ...
-
-class LValueType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.LValueType]:
-    ...
-
-class RValueType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.RValueType]:
-    ...
-
-class VoidType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.VoidType]:
-    ...
-
-class BoolType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.BoolType]:
-    ...
-
-class CharType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.CharType]:
-    ...
-
-class ShortType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.ShortType]:
-    ...
-
-class IntType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.IntType]:
-    ...
-
-class LongType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.LongType]:
-    ...
-
-class LongLongType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.LongLongType]:
-    ...
-
-class Int128Type(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.Int128Type]:
-    ...
-
-class HalfType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.HalfType]:
-    ...
-
-class BFloat16Type(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.BFloat16Type]:
-    ...
-
-class FloatType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.FloatType]:
-    ...
-
-class DoubleType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.DoubleType]:
-    ...
-
-class LongDoubleType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.LongDoubleType]:
-    ...
-
-class Float128Type(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.Float128Type]:
-    ...
-
-class ComplexType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.ComplexType]:
-    ...
-
-class PointerType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.PointerType]:
-    ...
-
-class ArrayType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.ArrayType]:
-    ...
-
-class VectorType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.VectorType]:
-    ...
-
-class DecayedType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.DecayedType]:
-    ...
-
-class AttributedType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.AttributedType]:
-    ...
-
-class AdjustedType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.AdjustedType]:
-    ...
-
-class ReferenceType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.ReferenceType]:
-    ...
-
-class TypeOfExprType(multiplier.ir.highlevel.Type):
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.TypeOfExprType]:
-    ...
-
-class TypeOfTypeType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.TypeOfTypeType]:
-    ...
-
-class AutoType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.AutoType]:
-    ...
-
-class AtomicType(multiplier.ir.highlevel.Type):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.highlevel.AtomicType]:
-    ...
diff --git a/bindings/Python/multiplier-stubs/ir/llvm/__init__.py b/bindings/Python/multiplier-stubs/ir/llvm/__init__.py
deleted file mode 100644
index b995b12a4..000000000
--- a/bindings/Python/multiplier-stubs/ir/llvm/__init__.py
+++ /dev/null
@@ -1,4690 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class Attribute(multiplier.ir.Attribute):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.Attribute]:
-    ...
-
-class CConvAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.CConvAttr]:
-    ...
-
-class ComdatAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.ComdatAttr]:
-    ...
-
-class LinkageAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LinkageAttr]:
-    ...
-
-class FramePointerKindAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.FramePointerKindAttr]:
-    ...
-
-class LoopVectorizeAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopVectorizeAttr]:
-    ...
-
-class LoopInterleaveAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopInterleaveAttr]:
-    ...
-
-class LoopUnrollAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopUnrollAttr]:
-    ...
-
-class LoopUnrollAndJamAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopUnrollAndJamAttr]:
-    ...
-
-class LoopLICMAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopLICMAttr]:
-    ...
-
-class LoopDistributeAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopDistributeAttr]:
-    ...
-
-class LoopPipelineAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopPipelineAttr]:
-    ...
-
-class LoopPeeledAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopPeeledAttr]:
-    ...
-
-class LoopUnswitchAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopUnswitchAttr]:
-    ...
-
-class LoopAnnotationAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.LoopAnnotationAttr]:
-    ...
-
-class DIExpressionElemAttr(multiplier.ir.llvm.Attribute):
-  opcode: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DIExpressionElemAttr]:
-    ...
-
-class DIExpressionAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DIExpressionAttr]:
-    ...
-
-class DINullTypeAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DINullTypeAttr]:
-    ...
-
-class DIBasicTypeAttr(multiplier.ir.llvm.Attribute):
-  tag: int
-  size_in_bits: int
-  encoding: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DIBasicTypeAttr]:
-    ...
-
-class DICompileUnitAttr(multiplier.ir.llvm.Attribute):
-  source_language: int
-  is_optimized: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DICompileUnitAttr]:
-    ...
-
-class DICompositeTypeAttr(multiplier.ir.llvm.Attribute):
-  tag: int
-  line: int
-  size_in_bits: int
-  align_in_bits: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DICompositeTypeAttr]:
-    ...
-
-class DIDerivedTypeAttr(multiplier.ir.llvm.Attribute):
-  tag: int
-  size_in_bits: int
-  align_in_bits: int
-  offset_in_bits: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DIDerivedTypeAttr]:
-    ...
-
-class DIFileAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DIFileAttr]:
-    ...
-
-class DIGlobalVariableExpressionAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DIGlobalVariableExpressionAttr]:
-    ...
-
-class DIGlobalVariableAttr(multiplier.ir.llvm.Attribute):
-  line: int
-  is_local_to_unit: bool
-  is_defined: bool
-  align_in_bits: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DIGlobalVariableAttr]:
-    ...
-
-class DILexicalBlockAttr(multiplier.ir.llvm.Attribute):
-  line: int
-  column: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DILexicalBlockAttr]:
-    ...
-
-class DILexicalBlockFileAttr(multiplier.ir.llvm.Attribute):
-  discriminator: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DILexicalBlockFileAttr]:
-    ...
-
-class DILocalVariableAttr(multiplier.ir.llvm.Attribute):
-  line: int
-  argument: int
-  align_in_bits: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DILocalVariableAttr]:
-    ...
-
-class DISubprogramAttr(multiplier.ir.llvm.Attribute):
-  line: int
-  scope_line: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DISubprogramAttr]:
-    ...
-
-class DIModuleAttr(multiplier.ir.llvm.Attribute):
-  line: int
-  is_decl: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DIModuleAttr]:
-    ...
-
-class DINamespaceAttr(multiplier.ir.llvm.Attribute):
-  export_symbols: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DINamespaceAttr]:
-    ...
-
-class DISubrangeAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DISubrangeAttr]:
-    ...
-
-class DISubroutineTypeAttr(multiplier.ir.llvm.Attribute):
-  calling_convention: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DISubroutineTypeAttr]:
-    ...
-
-class DILabelAttr(multiplier.ir.llvm.Attribute):
-  line: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.DILabelAttr]:
-    ...
-
-class MemoryEffectsAttr(multiplier.ir.llvm.Attribute):
-  is_read_write: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.MemoryEffectsAttr]:
-    ...
-
-class AliasScopeDomainAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.AliasScopeDomainAttr]:
-    ...
-
-class AliasScopeAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.AliasScopeAttr]:
-    ...
-
-class AccessGroupAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.AccessGroupAttr]:
-    ...
-
-class TBAARootAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.TBAARootAttr]:
-    ...
-
-class TBAAMemberAttr(multiplier.ir.llvm.Attribute):
-  offset: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.TBAAMemberAttr]:
-    ...
-
-class TBAATypeDescriptorAttr(multiplier.ir.llvm.Attribute):
-  id: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.TBAATypeDescriptorAttr]:
-    ...
-
-class TBAATagAttr(multiplier.ir.llvm.Attribute):
-  offset: int
-  constant: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.TBAATagAttr]:
-    ...
-
-class VScaleRangeAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.VScaleRangeAttr]:
-    ...
-
-class TargetFeaturesAttr(multiplier.ir.llvm.Attribute):
-  null_or_empty: bool
-  features_string: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.TargetFeaturesAttr]:
-    ...
-
-class IntegerOverflowFlagsAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.IntegerOverflowFlagsAttr]:
-    ...
-
-class FastmathFlagsAttr(multiplier.ir.llvm.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.llvm.FastmathFlagsAttr]:
-    ...
-
-class Operation(multiplier.ir.Operation):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.Operation]:
-    ...
-
-class AShrOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AShrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AShrOp]:
-    ...
-
-class AddOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AddOp]:
-    ...
-
-class AddrSpaceCastOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AddrSpaceCastOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AddrSpaceCastOp]:
-    ...
-
-class AddressOfOp(multiplier.ir.llvm.Operation):
-  global_name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AddressOfOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AddressOfOp]:
-    ...
-
-class AllocaOp(multiplier.ir.llvm.Operation):
-  alignment: Optional[int]
-  elem_type: multiplier.ir.Type
-  inalloca: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AllocaOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AllocaOp]:
-    ...
-
-class AndOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AndOp]:
-    ...
-
-class AtomicCmpXchgOp(multiplier.ir.llvm.Operation):
-  cmp: multiplier.ir.Value
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-  syncscope: Optional[str]
-  alignment: Optional[int]
-  weak: bool
-  volatile__: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AtomicCmpXchgOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AtomicCmpXchgOp]:
-    ...
-
-class AtomicRMWOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-  syncscope: Optional[str]
-  alignment: Optional[int]
-  volatile__: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AtomicRMWOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AtomicRMWOp]:
-    ...
-
-class BitcastOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.BitcastOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.BitcastOp]:
-    ...
-
-class BrOp(multiplier.ir.llvm.Operation):
-  dest_operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.BrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.BrOp]:
-    ...
-
-class CallIntrinsicOp(multiplier.ir.llvm.Operation):
-  arguments: Iterable[multiplier.ir.Operand]
-  results: multiplier.ir.Value
-  intrin: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CallIntrinsicOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CallIntrinsicOp]:
-    ...
-
-class CallOp(multiplier.ir.llvm.Operation):
-  callee_operands: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-  callee: Optional[str]
-  arg_operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CallOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CallOp]:
-    ...
-
-class ComdatOp(multiplier.ir.llvm.Operation):
-  body: multiplier.ir.Region
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ComdatOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ComdatOp]:
-    ...
-
-class ComdatSelectorOp(multiplier.ir.llvm.Operation):
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ComdatSelectorOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ComdatSelectorOp]:
-    ...
-
-class CondBrOp(multiplier.ir.llvm.Operation):
-  true_dest_operands: Iterable[multiplier.ir.Operand]
-  false_dest_operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CondBrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CondBrOp]:
-    ...
-
-class ConstantOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ConstantOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ConstantOp]:
-    ...
-
-class ExtractElementOp(multiplier.ir.llvm.Operation):
-  vector: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ExtractElementOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ExtractElementOp]:
-    ...
-
-class ExtractValueOp(multiplier.ir.llvm.Operation):
-  container: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ExtractValueOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ExtractValueOp]:
-    ...
-
-class FAddOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FAddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FAddOp]:
-    ...
-
-class FCmpOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FCmpOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FCmpOp]:
-    ...
-
-class FDivOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FDivOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FDivOp]:
-    ...
-
-class FMulOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FMulOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FMulOp]:
-    ...
-
-class FNegOp(multiplier.ir.llvm.Operation):
-  operand: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FNegOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FNegOp]:
-    ...
-
-class FPExtOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FPExtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FPExtOp]:
-    ...
-
-class FPToSIOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FPToSIOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FPToSIOp]:
-    ...
-
-class FPToUIOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FPToUIOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FPToUIOp]:
-    ...
-
-class FPTruncOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FPTruncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FPTruncOp]:
-    ...
-
-class FRemOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FRemOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FRemOp]:
-    ...
-
-class FSubOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FSubOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FSubOp]:
-    ...
-
-class FenceOp(multiplier.ir.llvm.Operation):
-  syncscope: Optional[str]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FenceOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FenceOp]:
-    ...
-
-class FreezeOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FreezeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FreezeOp]:
-    ...
-
-class GetElementPtrOp(multiplier.ir.llvm.Operation):
-  base: multiplier.ir.Value
-  dynamic_indices: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-  elem_type: multiplier.ir.Type
-  inbounds: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.GetElementPtrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.GetElementPtrOp]:
-    ...
-
-class GlobalCtorsOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.GlobalCtorsOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.GlobalCtorsOp]:
-    ...
-
-class GlobalDtorsOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.GlobalDtorsOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.GlobalDtorsOp]:
-    ...
-
-class GlobalOp(multiplier.ir.llvm.Operation):
-  initializer: multiplier.ir.Region
-  global_type: multiplier.ir.Type
-  constant: bool
-  name: str
-  dso_local: bool
-  thread_local__: bool
-  alignment: Optional[int]
-  addr_space: int
-  section: Optional[str]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.GlobalOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.GlobalOp]:
-    ...
-
-class ICmpOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ICmpOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ICmpOp]:
-    ...
-
-class InlineAsmOp(multiplier.ir.llvm.Operation):
-  operands: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-  assembly: str
-  constraints: str
-  has_side_effects: bool
-  is_align_stack: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.InlineAsmOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.InlineAsmOp]:
-    ...
-
-class InsertElementOp(multiplier.ir.llvm.Operation):
-  vector: multiplier.ir.Value
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.InsertElementOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.InsertElementOp]:
-    ...
-
-class InsertValueOp(multiplier.ir.llvm.Operation):
-  container: multiplier.ir.Value
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.InsertValueOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.InsertValueOp]:
-    ...
-
-class IntToPtrOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.IntToPtrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.IntToPtrOp]:
-    ...
-
-class InvokeOp(multiplier.ir.llvm.Operation):
-  callee_operands: Iterable[multiplier.ir.Operand]
-  normal_dest_operands: Iterable[multiplier.ir.Operand]
-  unwind_dest_operands: Iterable[multiplier.ir.Operand]
-  callee: Optional[str]
-  arg_operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.InvokeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.InvokeOp]:
-    ...
-
-class FuncOp(multiplier.ir.llvm.Operation):
-  body: Optional[multiplier.ir.Region]
-  name: str
-  visibility: Optional[str]
-  dso_local: bool
-  personality: Optional[str]
-  garbage_collector: Optional[str]
-  function_entry_count: Optional[int]
-  arm_streaming: Optional[bool]
-  arm_locally_streaming: Optional[bool]
-  arm_streaming_compatible: Optional[bool]
-  arm_new_za: Optional[bool]
-  arm_preserves_za: Optional[bool]
-  arm_shared_za: Optional[bool]
-  section: Optional[str]
-  alignment: Optional[int]
-  target_cpu: Optional[str]
-  is_var_arg: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FuncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FuncOp]:
-    ...
-
-class LShrOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.LShrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.LShrOp]:
-    ...
-
-class LandingpadOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-  cleanup: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.LandingpadOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.LandingpadOp]:
-    ...
-
-class LinkerOptionsOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.LinkerOptionsOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.LinkerOptionsOp]:
-    ...
-
-class LoadOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-  alignment: Optional[int]
-  volatile__: bool
-  nontemporal: bool
-  invariant: bool
-  syncscope: Optional[str]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.LoadOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.LoadOp]:
-    ...
-
-class MulOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MulOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MulOp]:
-    ...
-
-class NoneTokenOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.NoneTokenOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.NoneTokenOp]:
-    ...
-
-class OrOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.OrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.OrOp]:
-    ...
-
-class PoisonOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.PoisonOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.PoisonOp]:
-    ...
-
-class PtrToIntOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.PtrToIntOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.PtrToIntOp]:
-    ...
-
-class ResumeOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ResumeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ResumeOp]:
-    ...
-
-class ReturnOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ReturnOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ReturnOp]:
-    ...
-
-class SDivOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SDivOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SDivOp]:
-    ...
-
-class SExtOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SExtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SExtOp]:
-    ...
-
-class SIToFPOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SIToFPOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SIToFPOp]:
-    ...
-
-class SRemOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SRemOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SRemOp]:
-    ...
-
-class SelectOp(multiplier.ir.llvm.Operation):
-  condition: multiplier.ir.Value
-  true_value: multiplier.ir.Value
-  false_value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SelectOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SelectOp]:
-    ...
-
-class ShlOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ShlOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ShlOp]:
-    ...
-
-class ShuffleVectorOp(multiplier.ir.llvm.Operation):
-  v1: multiplier.ir.Value
-  v2: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ShuffleVectorOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ShuffleVectorOp]:
-    ...
-
-class StoreOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  alignment: Optional[int]
-  volatile__: bool
-  nontemporal: bool
-  syncscope: Optional[str]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.StoreOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.StoreOp]:
-    ...
-
-class SubOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SubOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SubOp]:
-    ...
-
-class SwitchOp(multiplier.ir.llvm.Operation):
-  default_operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SwitchOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SwitchOp]:
-    ...
-
-class TruncOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.TruncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.TruncOp]:
-    ...
-
-class UDivOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UDivOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UDivOp]:
-    ...
-
-class UIToFPOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UIToFPOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UIToFPOp]:
-    ...
-
-class URemOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.URemOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.URemOp]:
-    ...
-
-class UndefOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UndefOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UndefOp]:
-    ...
-
-class UnreachableOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UnreachableOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UnreachableOp]:
-    ...
-
-class XOrOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.XOrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.XOrOp]:
-    ...
-
-class ZExtOp(multiplier.ir.llvm.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ZExtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ZExtOp]:
-    ...
-
-class ZeroOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ZeroOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ZeroOp]:
-    ...
-
-class AbsOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-  is_int_min_poison: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AbsOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AbsOp]:
-    ...
-
-class AnnotationOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AnnotationOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AnnotationOp]:
-    ...
-
-class AssumeOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.AssumeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.AssumeOp]:
-    ...
-
-class BitReverseOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.BitReverseOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.BitReverseOp]:
-    ...
-
-class ByteSwapOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ByteSwapOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ByteSwapOp]:
-    ...
-
-class CopySignOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CopySignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CopySignOp]:
-    ...
-
-class CoroAlignOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroAlignOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroAlignOp]:
-    ...
-
-class CoroBeginOp(multiplier.ir.llvm.Operation):
-  token: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroBeginOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroBeginOp]:
-    ...
-
-class CoroEndOp(multiplier.ir.llvm.Operation):
-  retvals: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroEndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroEndOp]:
-    ...
-
-class CoroFreeOp(multiplier.ir.llvm.Operation):
-  id: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroFreeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroFreeOp]:
-    ...
-
-class CoroIdOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroIdOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroIdOp]:
-    ...
-
-class CoroPromiseOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroPromiseOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroPromiseOp]:
-    ...
-
-class CoroResumeOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroResumeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroResumeOp]:
-    ...
-
-class CoroSaveOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroSaveOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroSaveOp]:
-    ...
-
-class CoroSizeOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroSizeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroSizeOp]:
-    ...
-
-class CoroSuspendOp(multiplier.ir.llvm.Operation):
-  save: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CoroSuspendOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CoroSuspendOp]:
-    ...
-
-class CosOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CosOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CosOp]:
-    ...
-
-class CountLeadingZerosOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-  is_zero_poison: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CountLeadingZerosOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CountLeadingZerosOp]:
-    ...
-
-class CountTrailingZerosOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-  is_zero_poison: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CountTrailingZerosOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CountTrailingZerosOp]:
-    ...
-
-class CtPopOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.CtPopOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.CtPopOp]:
-    ...
-
-class DbgDeclareOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.DbgDeclareOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.DbgDeclareOp]:
-    ...
-
-class DbgLabelOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.DbgLabelOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.DbgLabelOp]:
-    ...
-
-class DbgValueOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.DbgValueOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.DbgValueOp]:
-    ...
-
-class DebugTrapOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.DebugTrapOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.DebugTrapOp]:
-    ...
-
-class EhTypeidForOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.EhTypeidForOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.EhTypeidForOp]:
-    ...
-
-class Exp2Op(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.Exp2Op]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.Exp2Op]:
-    ...
-
-class ExpOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ExpOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ExpOp]:
-    ...
-
-class ExpectOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ExpectOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ExpectOp]:
-    ...
-
-class ExpectWithProbabilityOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ExpectWithProbabilityOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ExpectWithProbabilityOp]:
-    ...
-
-class FAbsOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FAbsOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FAbsOp]:
-    ...
-
-class FCeilOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FCeilOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FCeilOp]:
-    ...
-
-class FFloorOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FFloorOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FFloorOp]:
-    ...
-
-class FMAOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  c: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FMAOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FMAOp]:
-    ...
-
-class FMulAddOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  c: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FMulAddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FMulAddOp]:
-    ...
-
-class FTruncOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FTruncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FTruncOp]:
-    ...
-
-class FShlOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  c: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FShlOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FShlOp]:
-    ...
-
-class FShrOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  c: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FShrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FShrOp]:
-    ...
-
-class GetActiveLaneMaskOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.GetActiveLaneMaskOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.GetActiveLaneMaskOp]:
-    ...
-
-class InvariantEndOp(multiplier.ir.llvm.Operation):
-  size: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.InvariantEndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.InvariantEndOp]:
-    ...
-
-class InvariantStartOp(multiplier.ir.llvm.Operation):
-  size: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.InvariantStartOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.InvariantStartOp]:
-    ...
-
-class IsConstantOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.IsConstantOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.IsConstantOp]:
-    ...
-
-class IsFPClassOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-  bit: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.IsFPClassOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.IsFPClassOp]:
-    ...
-
-class LifetimeEndOp(multiplier.ir.llvm.Operation):
-  size: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.LifetimeEndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.LifetimeEndOp]:
-    ...
-
-class LifetimeStartOp(multiplier.ir.llvm.Operation):
-  size: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.LifetimeStartOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.LifetimeStartOp]:
-    ...
-
-class RoundAndCastToLongLongOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.RoundAndCastToLongLongOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.RoundAndCastToLongLongOp]:
-    ...
-
-class RoundAndCastToNearestLongLongOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.RoundAndCastToNearestLongLongOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.RoundAndCastToNearestLongLongOp]:
-    ...
-
-class Log10Op(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.Log10Op]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.Log10Op]:
-    ...
-
-class Log2Op(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.Log2Op]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.Log2Op]:
-    ...
-
-class LogOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.LogOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.LogOp]:
-    ...
-
-class RoundAndCastToLongOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.RoundAndCastToLongOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.RoundAndCastToLongOp]:
-    ...
-
-class RoundAndCastToNearestLongOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.RoundAndCastToNearestLongOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.RoundAndCastToNearestLongOp]:
-    ...
-
-class MaskedLoadOp(multiplier.ir.llvm.Operation):
-  mask: multiplier.ir.Value
-  pass_thru: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-  alignment: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MaskedLoadOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MaskedLoadOp]:
-    ...
-
-class MaskedStoreOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  alignment: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MaskedStoreOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MaskedStoreOp]:
-    ...
-
-class MatrixColumnMajorLoadOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-  is_volatile: bool
-  rows: int
-  columns: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MatrixColumnMajorLoadOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MatrixColumnMajorLoadOp]:
-    ...
-
-class MatrixColumnMajorStoreOp(multiplier.ir.llvm.Operation):
-  matrix: multiplier.ir.Value
-  is_volatile: bool
-  rows: int
-  columns: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MatrixColumnMajorStoreOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MatrixColumnMajorStoreOp]:
-    ...
-
-class MatrixMultiplyOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  result: multiplier.ir.Value
-  lhs_rows: int
-  lhs_columns: int
-  rhs_columns: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MatrixMultiplyOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MatrixMultiplyOp]:
-    ...
-
-class MatrixTransposeOp(multiplier.ir.llvm.Operation):
-  matrix: multiplier.ir.Value
-  result: multiplier.ir.Value
-  rows: int
-  columns: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MatrixTransposeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MatrixTransposeOp]:
-    ...
-
-class MaxNumOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MaxNumOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MaxNumOp]:
-    ...
-
-class MaximumOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MaximumOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MaximumOp]:
-    ...
-
-class MemcpyInlineOp(multiplier.ir.llvm.Operation):
-  is_volatile: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MemcpyInlineOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MemcpyInlineOp]:
-    ...
-
-class MemcpyOp(multiplier.ir.llvm.Operation):
-  is_volatile: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MemcpyOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MemcpyOp]:
-    ...
-
-class MemmoveOp(multiplier.ir.llvm.Operation):
-  is_volatile: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MemmoveOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MemmoveOp]:
-    ...
-
-class MemsetOp(multiplier.ir.llvm.Operation):
-  is_volatile: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MemsetOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MemsetOp]:
-    ...
-
-class MinNumOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MinNumOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MinNumOp]:
-    ...
-
-class MinimumOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MinimumOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MinimumOp]:
-    ...
-
-class RoundToNearbyIntOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.RoundToNearbyIntOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.RoundToNearbyIntOp]:
-    ...
-
-class NoAliasScopeDeclOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.NoAliasScopeDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.NoAliasScopeDeclOp]:
-    ...
-
-class PowIOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.PowIOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.PowIOp]:
-    ...
-
-class FPowOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.FPowOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.FPowOp]:
-    ...
-
-class PrefetchOp(multiplier.ir.llvm.Operation):
-  rw: int
-  hint: int
-  cache: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.PrefetchOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.PrefetchOp]:
-    ...
-
-class PtrAnnotationOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.PtrAnnotationOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.PtrAnnotationOp]:
-    ...
-
-class RoundToIntOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.RoundToIntOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.RoundToIntOp]:
-    ...
-
-class RoundToNearestEvenOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.RoundToNearestEvenOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.RoundToNearestEvenOp]:
-    ...
-
-class RoundToNearestOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.RoundToNearestOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.RoundToNearestOp]:
-    ...
-
-class SAddSatOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SAddSatOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SAddSatOp]:
-    ...
-
-class SAddWithOverflowOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SAddWithOverflowOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SAddWithOverflowOp]:
-    ...
-
-class SMaxOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SMaxOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SMaxOp]:
-    ...
-
-class SMinOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SMinOp]:
-    ...
-
-class SMulWithOverflowOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SMulWithOverflowOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SMulWithOverflowOp]:
-    ...
-
-class SSACopyOp(multiplier.ir.llvm.Operation):
-  operand: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SSACopyOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SSACopyOp]:
-    ...
-
-class SShlSatOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SShlSatOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SShlSatOp]:
-    ...
-
-class SSubSatOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SSubSatOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SSubSatOp]:
-    ...
-
-class SSubWithOverflowOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SSubWithOverflowOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SSubWithOverflowOp]:
-    ...
-
-class SinOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SinOp]:
-    ...
-
-class SqrtOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.SqrtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.SqrtOp]:
-    ...
-
-class StackRestoreOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.StackRestoreOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.StackRestoreOp]:
-    ...
-
-class StackSaveOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.StackSaveOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.StackSaveOp]:
-    ...
-
-class StepVectorOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.StepVectorOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.StepVectorOp]:
-    ...
-
-class ThreadLocalAddressOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.ThreadLocalAddressOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.ThreadLocalAddressOp]:
-    ...
-
-class TrapOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.TrapOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.TrapOp]:
-    ...
-
-class UAddSatOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UAddSatOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UAddSatOp]:
-    ...
-
-class UAddWithOverflowOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UAddWithOverflowOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UAddWithOverflowOp]:
-    ...
-
-class UBSanTrapOp(multiplier.ir.llvm.Operation):
-  failure_kind: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UBSanTrapOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UBSanTrapOp]:
-    ...
-
-class UMaxOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UMaxOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UMaxOp]:
-    ...
-
-class UMinOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UMinOp]:
-    ...
-
-class UMulWithOverflowOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UMulWithOverflowOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UMulWithOverflowOp]:
-    ...
-
-class UShlSatOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.UShlSatOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.UShlSatOp]:
-    ...
-
-class USubSatOp(multiplier.ir.llvm.Operation):
-  a: multiplier.ir.Value
-  b: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.USubSatOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.USubSatOp]:
-    ...
-
-class USubWithOverflowOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.USubWithOverflowOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.USubWithOverflowOp]:
-    ...
-
-class VPAShrOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPAShrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPAShrOp]:
-    ...
-
-class VPAddOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPAddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPAddOp]:
-    ...
-
-class VPAndOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPAndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPAndOp]:
-    ...
-
-class VPFAddOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFAddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFAddOp]:
-    ...
-
-class VPFDivOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFDivOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFDivOp]:
-    ...
-
-class VPFMulAddOp(multiplier.ir.llvm.Operation):
-  op1: multiplier.ir.Value
-  op2: multiplier.ir.Value
-  op3: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFMulAddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFMulAddOp]:
-    ...
-
-class VPFMulOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFMulOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFMulOp]:
-    ...
-
-class VPFNegOp(multiplier.ir.llvm.Operation):
-  op: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFNegOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFNegOp]:
-    ...
-
-class VPFPExtOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFPExtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFPExtOp]:
-    ...
-
-class VPFPToSIOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFPToSIOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFPToSIOp]:
-    ...
-
-class VPFPToUIOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFPToUIOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFPToUIOp]:
-    ...
-
-class VPFPTruncOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFPTruncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFPTruncOp]:
-    ...
-
-class VPFRemOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFRemOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFRemOp]:
-    ...
-
-class VPFSubOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFSubOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFSubOp]:
-    ...
-
-class VPFmaOp(multiplier.ir.llvm.Operation):
-  op1: multiplier.ir.Value
-  op2: multiplier.ir.Value
-  op3: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPFmaOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPFmaOp]:
-    ...
-
-class VPIntToPtrOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPIntToPtrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPIntToPtrOp]:
-    ...
-
-class VPLShrOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPLShrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPLShrOp]:
-    ...
-
-class VPLoadOp(multiplier.ir.llvm.Operation):
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPLoadOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPLoadOp]:
-    ...
-
-class VPMergeMinOp(multiplier.ir.llvm.Operation):
-  cond: multiplier.ir.Value
-  true_val: multiplier.ir.Value
-  false_val: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPMergeMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPMergeMinOp]:
-    ...
-
-class VPMulOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPMulOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPMulOp]:
-    ...
-
-class VPOrOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPOrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPOrOp]:
-    ...
-
-class VPPtrToIntOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPPtrToIntOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPPtrToIntOp]:
-    ...
-
-class VPReduceAddOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceAddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceAddOp]:
-    ...
-
-class VPReduceAndOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceAndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceAndOp]:
-    ...
-
-class VPReduceFAddOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceFAddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceFAddOp]:
-    ...
-
-class VPReduceFMaxOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceFMaxOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceFMaxOp]:
-    ...
-
-class VPReduceFMinOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceFMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceFMinOp]:
-    ...
-
-class VPReduceFMulOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceFMulOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceFMulOp]:
-    ...
-
-class VPReduceMulOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceMulOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceMulOp]:
-    ...
-
-class VPReduceOrOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceOrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceOrOp]:
-    ...
-
-class VPReduceSMaxOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceSMaxOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceSMaxOp]:
-    ...
-
-class VPReduceSMinOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceSMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceSMinOp]:
-    ...
-
-class VPReduceUMaxOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceUMaxOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceUMaxOp]:
-    ...
-
-class VPReduceUMinOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceUMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceUMinOp]:
-    ...
-
-class VPReduceXorOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPReduceXorOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPReduceXorOp]:
-    ...
-
-class VPSDivOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPSDivOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPSDivOp]:
-    ...
-
-class VPSExtOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPSExtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPSExtOp]:
-    ...
-
-class VPSIToFPOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPSIToFPOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPSIToFPOp]:
-    ...
-
-class VPSRemOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPSRemOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPSRemOp]:
-    ...
-
-class VPSelectMinOp(multiplier.ir.llvm.Operation):
-  cond: multiplier.ir.Value
-  true_val: multiplier.ir.Value
-  false_val: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPSelectMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPSelectMinOp]:
-    ...
-
-class VPShlOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPShlOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPShlOp]:
-    ...
-
-class VPStoreOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPStoreOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPStoreOp]:
-    ...
-
-class VPStridedLoadOp(multiplier.ir.llvm.Operation):
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPStridedLoadOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPStridedLoadOp]:
-    ...
-
-class VPStridedStoreOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  mask: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPStridedStoreOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPStridedStoreOp]:
-    ...
-
-class VPSubOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPSubOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPSubOp]:
-    ...
-
-class VPTruncOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPTruncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPTruncOp]:
-    ...
-
-class VPUDivOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPUDivOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPUDivOp]:
-    ...
-
-class VPUIToFPOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPUIToFPOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPUIToFPOp]:
-    ...
-
-class VPURemOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPURemOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPURemOp]:
-    ...
-
-class VPXorOp(multiplier.ir.llvm.Operation):
-  left: multiplier.ir.Value
-  right: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPXorOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPXorOp]:
-    ...
-
-class VPZExtOp(multiplier.ir.llvm.Operation):
-  source: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VPZExtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VPZExtOp]:
-    ...
-
-class VaCopyOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VaCopyOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VaCopyOp]:
-    ...
-
-class VaEndOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VaEndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VaEndOp]:
-    ...
-
-class VaStartOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VaStartOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VaStartOp]:
-    ...
-
-class VarAnnotationOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VarAnnotationOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VarAnnotationOp]:
-    ...
-
-class MaskedCompressStoreOp(multiplier.ir.llvm.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MaskedCompressStoreOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MaskedCompressStoreOp]:
-    ...
-
-class MaskedExpandLoadOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MaskedExpandLoadOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MaskedExpandLoadOp]:
-    ...
-
-class MaskedGatherOp(multiplier.ir.llvm.Operation):
-  ptrs: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  pass_thru: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-  alignment: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MaskedGatherOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MaskedGatherOp]:
-    ...
-
-class MaskedScatterOp(multiplier.ir.llvm.Operation):
-  value: multiplier.ir.Value
-  ptrs: multiplier.ir.Value
-  mask: multiplier.ir.Value
-  alignment: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.MaskedScatterOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.MaskedScatterOp]:
-    ...
-
-class VectorExtractOp(multiplier.ir.llvm.Operation):
-  srcvec: multiplier.ir.Value
-  result: multiplier.ir.Value
-  pos: int
-  src_vector_bit_width: int
-  res_vector_bit_width: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorExtractOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorExtractOp]:
-    ...
-
-class VectorInsertOp(multiplier.ir.llvm.Operation):
-  dstvec: multiplier.ir.Value
-  srcvec: multiplier.ir.Value
-  result: multiplier.ir.Value
-  pos: int
-  src_vector_bit_width: int
-  dst_vector_bit_width: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorInsertOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorInsertOp]:
-    ...
-
-class VectorReduceAddOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceAddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceAddOp]:
-    ...
-
-class VectorReduceAndOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceAndOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceAndOp]:
-    ...
-
-class VectorReduceFAddOp(multiplier.ir.llvm.Operation):
-  input: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceFAddOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceFAddOp]:
-    ...
-
-class VectorReduceFMaxOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceFMaxOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceFMaxOp]:
-    ...
-
-class VectorReduceFMaximumOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceFMaximumOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceFMaximumOp]:
-    ...
-
-class VectorReduceFMinOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceFMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceFMinOp]:
-    ...
-
-class VectorReduceFMinimumOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceFMinimumOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceFMinimumOp]:
-    ...
-
-class VectorReduceFMulOp(multiplier.ir.llvm.Operation):
-  input: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceFMulOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceFMulOp]:
-    ...
-
-class VectorReduceMulOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceMulOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceMulOp]:
-    ...
-
-class VectorReduceOrOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceOrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceOrOp]:
-    ...
-
-class VectorReduceSMaxOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceSMaxOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceSMaxOp]:
-    ...
-
-class VectorReduceSMinOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceSMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceSMinOp]:
-    ...
-
-class VectorReduceUMaxOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceUMaxOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceUMaxOp]:
-    ...
-
-class VectorReduceUMinOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceUMinOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceUMinOp]:
-    ...
-
-class VectorReduceXorOp(multiplier.ir.llvm.Operation):
-  IN: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VectorReduceXorOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VectorReduceXorOp]:
-    ...
-
-class VScaleOp(multiplier.ir.llvm.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.llvm.VScaleOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.llvm.VScaleOp]:
-    ...
-
-class Type(multiplier.ir.Type):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Type) -> Optional[multiplier.ir.llvm.Type]:
-    ...
-
-class ArrayType(multiplier.ir.llvm.Type):
-  num_elements: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.llvm.ArrayType]:
-    ...
-
-class FunctionType(multiplier.ir.llvm.Type):
-  is_var_arg: bool
-  num_params: int
-  params: Iterable[multiplier.ir.Type]
-  var_arg: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.llvm.FunctionType]:
-    ...
-
-class PointerType(multiplier.ir.llvm.Type):
-  address_space: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.llvm.PointerType]:
-    ...
-
-class FixedVectorType(multiplier.ir.llvm.Type):
-  num_elements: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.llvm.FixedVectorType]:
-    ...
-
-class ScalableVectorType(multiplier.ir.llvm.Type):
-  min_num_elements: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.llvm.ScalableVectorType]:
-    ...
-
-class TargetExtType(multiplier.ir.llvm.Type):
-  supports_mem_ops: bool
-  ext_type_name: str
-  type_params: Iterable[multiplier.ir.Type]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.llvm.TargetExtType]:
-    ...
diff --git a/bindings/Python/multiplier-stubs/ir/lowlevel/__init__.py b/bindings/Python/multiplier-stubs/ir/lowlevel/__init__.py
deleted file mode 100644
index 5e8064072..000000000
--- a/bindings/Python/multiplier-stubs/ir/lowlevel/__init__.py
+++ /dev/null
@@ -1,337 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class Operation(multiplier.ir.Operation):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.Operation]:
-    ...
-
-class AllocaOp(multiplier.ir.lowlevel.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.AllocaOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.AllocaOp]:
-    ...
-
-class ArgAllocaOp(multiplier.ir.lowlevel.Operation):
-  fn_arg: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.ArgAllocaOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.ArgAllocaOp]:
-    ...
-
-class BrOp(multiplier.ir.lowlevel.Operation):
-  operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.BrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.BrOp]:
-    ...
-
-class ConcatOp(multiplier.ir.lowlevel.Operation):
-  arguments: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.ConcatOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.ConcatOp]:
-    ...
-
-class CondBrOp(multiplier.ir.lowlevel.Operation):
-  cond: multiplier.ir.Value
-  true_operands: Iterable[multiplier.ir.Operand]
-  false_operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.CondBrOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.CondBrOp]:
-    ...
-
-class CondScopeRetOp(multiplier.ir.lowlevel.Operation):
-  cond: multiplier.ir.Value
-  dest_operands: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.CondScopeRetOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.CondScopeRetOp]:
-    ...
-
-class ExtractOp(multiplier.ir.lowlevel.Operation):
-  argument: multiplier.ir.Value
-  result: multiplier.ir.Value
-  size: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.ExtractOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.ExtractOp]:
-    ...
-
-class InitializeVarOp(multiplier.ir.lowlevel.Operation):
-  var: multiplier.ir.Value
-  elements: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.InitializeVarOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.InitializeVarOp]:
-    ...
-
-class InlineScopeOp(multiplier.ir.lowlevel.Operation):
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.InlineScopeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.InlineScopeOp]:
-    ...
-
-class LoadOp(multiplier.ir.lowlevel.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.LoadOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.LoadOp]:
-    ...
-
-class FuncOp(multiplier.ir.lowlevel.Operation):
-  body: Optional[multiplier.ir.Region]
-  name: str
-  function_type: multiplier.ir.Type
-  visibility: Optional[str]
-  is_var_arg: bool
-  callable_results: Iterable[multiplier.ir.Type]
-  argument_types: Iterable[multiplier.ir.Type]
-  result_types: Iterable[multiplier.ir.Type]
-  is_declaration: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.FuncOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.FuncOp]:
-    ...
-
-class StructGEPOp(multiplier.ir.lowlevel.Operation):
-  record: multiplier.ir.Value
-  element: multiplier.ir.Value
-  idx: int
-  field: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.StructGEPOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.StructGEPOp]:
-    ...
-
-class ReturnOp(multiplier.ir.lowlevel.Operation):
-  result: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.ReturnOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.ReturnOp]:
-    ...
-
-class ScopeOp(multiplier.ir.lowlevel.Operation):
-  body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.ScopeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.ScopeOp]:
-    ...
-
-class ScopeRecurseOp(multiplier.ir.lowlevel.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.ScopeRecurseOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.ScopeRecurseOp]:
-    ...
-
-class ScopeRetOp(multiplier.ir.lowlevel.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.ScopeRetOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.ScopeRetOp]:
-    ...
-
-class StoreOp(multiplier.ir.lowlevel.Operation):
-  value: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.StoreOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.StoreOp]:
-    ...
-
-class SubscriptOp(multiplier.ir.lowlevel.Operation):
-  array: multiplier.ir.Value
-  index: multiplier.ir.Value
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.SubscriptOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.SubscriptOp]:
-    ...
-
-class UninitializedVarOp(multiplier.ir.lowlevel.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.lowlevel.UninitializedVarOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.lowlevel.UninitializedVarOp]:
-    ...
diff --git a/bindings/Python/multiplier-stubs/ir/memref/__init__.py b/bindings/Python/multiplier-stubs/ir/memref/__init__.py
deleted file mode 100644
index d4f8d6604..000000000
--- a/bindings/Python/multiplier-stubs/ir/memref/__init__.py
+++ /dev/null
@@ -1,533 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class Operation(multiplier.ir.Operation):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.Operation]:
-    ...
-
-class AssumeAlignmentOp(multiplier.ir.memref.Operation):
-  alignment: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.AssumeAlignmentOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.AssumeAlignmentOp]:
-    ...
-
-class AtomicRMWOp(multiplier.ir.memref.Operation):
-  value: multiplier.ir.Value
-  indices: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.AtomicRMWOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.AtomicRMWOp]:
-    ...
-
-class AtomicYieldOp(multiplier.ir.memref.Operation):
-  result: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.AtomicYieldOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.AtomicYieldOp]:
-    ...
-
-class CopyOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.CopyOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.CopyOp]:
-    ...
-
-class GenericAtomicRMWOp(multiplier.ir.memref.Operation):
-  indices: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-  atomic_body: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.GenericAtomicRMWOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.GenericAtomicRMWOp]:
-    ...
-
-class LoadOp(multiplier.ir.memref.Operation):
-  indices: Iterable[multiplier.ir.Operand]
-  result: multiplier.ir.Value
-  nontemporal: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.LoadOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.LoadOp]:
-    ...
-
-class AllocOp(multiplier.ir.memref.Operation):
-  dynamic_sizes: Iterable[multiplier.ir.Operand]
-  symbol_operands: Iterable[multiplier.ir.Operand]
-  alignment: Optional[int]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.AllocOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.AllocOp]:
-    ...
-
-class AllocaOp(multiplier.ir.memref.Operation):
-  dynamic_sizes: Iterable[multiplier.ir.Operand]
-  symbol_operands: Iterable[multiplier.ir.Operand]
-  alignment: Optional[int]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.AllocaOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.AllocaOp]:
-    ...
-
-class AllocaScopeOp(multiplier.ir.memref.Operation):
-  results: Iterable[multiplier.ir.Result]
-  body_region: multiplier.ir.Region
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.AllocaScopeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.AllocaScopeOp]:
-    ...
-
-class AllocaScopeReturnOp(multiplier.ir.memref.Operation):
-  results: Iterable[multiplier.ir.Operand]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.AllocaScopeReturnOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.AllocaScopeReturnOp]:
-    ...
-
-class CastOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.CastOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.CastOp]:
-    ...
-
-class CollapseShapeOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.CollapseShapeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.CollapseShapeOp]:
-    ...
-
-class DeallocOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.DeallocOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.DeallocOp]:
-    ...
-
-class DimOp(multiplier.ir.memref.Operation):
-  source: multiplier.ir.Value
-  constant_index: Optional[int]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.DimOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.DimOp]:
-    ...
-
-class DMAStartOp(multiplier.ir.memref.Operation):
-  operands: Iterable[multiplier.ir.Operand]
-  src_mem_ref_rank: int
-  dst_mem_ref_rank: int
-  src_memory_space: int
-  dst_memory_space: int
-  tag_mem_ref_rank: int
-  is_dest_memory_space_faster: bool
-  is_src_memory_space_faster: bool
-  faster_mem_pos: int
-  is_strided: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.DMAStartOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.DMAStartOp]:
-    ...
-
-class DMAWaitOp(multiplier.ir.memref.Operation):
-  tag_indices: Iterable[multiplier.ir.Operand]
-  tag_mem_ref_rank: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.DMAWaitOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.DMAWaitOp]:
-    ...
-
-class ExpandShapeOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.ExpandShapeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.ExpandShapeOp]:
-    ...
-
-class ExtractAlignedPointerAsIndexOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.ExtractAlignedPointerAsIndexOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.ExtractAlignedPointerAsIndexOp]:
-    ...
-
-class ExtractStridedMetadataOp(multiplier.ir.memref.Operation):
-  base_buffer: multiplier.ir.Value
-  sizes: Iterable[multiplier.ir.Result]
-  strides: Iterable[multiplier.ir.Result]
-  view_source: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.ExtractStridedMetadataOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.ExtractStridedMetadataOp]:
-    ...
-
-class GetGlobalOp(multiplier.ir.memref.Operation):
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.GetGlobalOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.GetGlobalOp]:
-    ...
-
-class GlobalOp(multiplier.ir.memref.Operation):
-  name: str
-  visibility: Optional[str]
-  constant: bool
-  alignment: Optional[int]
-  is_external: bool
-  is_uninitialized: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.GlobalOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.GlobalOp]:
-    ...
-
-class MemorySpaceCastOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.MemorySpaceCastOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.MemorySpaceCastOp]:
-    ...
-
-class PrefetchOp(multiplier.ir.memref.Operation):
-  indices: Iterable[multiplier.ir.Operand]
-  is_write: bool
-  locality_hint: int
-  is_data_cache: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.PrefetchOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.PrefetchOp]:
-    ...
-
-class RankOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.RankOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.RankOp]:
-    ...
-
-class ReallocOp(multiplier.ir.memref.Operation):
-  alignment: Optional[int]
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.ReallocOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.ReallocOp]:
-    ...
-
-class ReinterpretCastOp(multiplier.ir.memref.Operation):
-  offsets: Iterable[multiplier.ir.Operand]
-  sizes: Iterable[multiplier.ir.Operand]
-  strides: Iterable[multiplier.ir.Operand]
-  dynamic_sizes: Iterable[multiplier.ir.Operand]
-  result_rank: int
-  offset_size_and_stride_start_operand_index: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.ReinterpretCastOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.ReinterpretCastOp]:
-    ...
-
-class ReshapeOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.ReshapeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.ReshapeOp]:
-    ...
-
-class StoreOp(multiplier.ir.memref.Operation):
-  value: multiplier.ir.Value
-  indices: Iterable[multiplier.ir.Operand]
-  nontemporal: bool
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.StoreOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.StoreOp]:
-    ...
-
-class TransposeOp(multiplier.ir.memref.Operation):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.TransposeOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.TransposeOp]:
-    ...
-
-class ViewOp(multiplier.ir.memref.Operation):
-  sizes: Iterable[multiplier.ir.Operand]
-  view_source: multiplier.ir.Value
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.ViewOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.ViewOp]:
-    ...
-
-class SubViewOp(multiplier.ir.memref.Operation):
-  offsets: Iterable[multiplier.ir.Operand]
-  sizes: Iterable[multiplier.ir.Operand]
-  strides: Iterable[multiplier.ir.Operand]
-  view_source: multiplier.ir.Value
-  dynamic_sizes: Iterable[multiplier.ir.Operand]
-  offset_size_and_stride_start_operand_index: int
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.memref.SubViewOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.memref.SubViewOp]:
-    ...
diff --git a/bindings/Python/multiplier-stubs/ir/meta/__init__.py b/bindings/Python/multiplier-stubs/ir/meta/__init__.py
deleted file mode 100644
index 260fbbace..000000000
--- a/bindings/Python/multiplier-stubs/ir/meta/__init__.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class Attribute(multiplier.ir.Attribute):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Attribute) -> Optional[multiplier.ir.meta.Attribute]:
-    ...
-
-class IdentifierAttr(multiplier.ir.meta.Attribute):
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.AttributeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Attribute) -> Optional[multiplier.ir.meta.IdentifierAttr]:
-    ...
diff --git a/bindings/Python/multiplier-stubs/ir/unsupported/__init__.py b/bindings/Python/multiplier-stubs/ir/unsupported/__init__.py
deleted file mode 100644
index bbbf652b5..000000000
--- a/bindings/Python/multiplier-stubs/ir/unsupported/__init__.py
+++ /dev/null
@@ -1,82 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-# Auto-generated file; do not modify!
-
-from abc import ABC
-from enum import IntEnum
-from typing import Generator, Iterable, Mapping, Optional, overload, Sequence, Tuple
-import pathlib
-import multiplier
-import multiplier.ir
-import multiplier.ast
-import multiplier.ir.abi
-import multiplier.ir.llvm
-import multiplier.ir.core
-import multiplier.ir.meta
-import multiplier.frontend
-import multiplier.ir.memref
-import multiplier.ir.builtin
-import multiplier.ir.lowlevel
-import multiplier.ir.highlevel
-import multiplier.ir.unsupported
-
-class Operation(multiplier.ir.Operation):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Operation) -> Optional[multiplier.ir.unsupported.Operation]:
-    ...
-
-class UnsupportedDeclOp(multiplier.ir.unsupported.Operation):
-  body: multiplier.ir.Region
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.unsupported.UnsupportedDeclOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.unsupported.UnsupportedDeclOp]:
-    ...
-
-class UnsupportedStmtOp(multiplier.ir.unsupported.Operation):
-  result: multiplier.ir.Value
-  children: Iterable[multiplier.ir.Region]
-  name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.OperationKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Operation) -> Optional[multiplier.ir.unsupported.UnsupportedStmtOp]:
-    ...
-
-  @staticmethod
-  def producing(val: multiplier.ir.Value) -> Optional[multiplier.ir.unsupported.UnsupportedStmtOp]:
-    ...
-
-class Type(multiplier.ir.Type):
-
-  @staticmethod
-  def FROM(arg_0: multiplier.ir.Type) -> Optional[multiplier.ir.unsupported.Type]:
-    ...
-
-class UnsupportedType(multiplier.ir.unsupported.Type):
-  origin_name: str
-
-  @staticmethod
-  def static_kind() -> multiplier.ir.TypeKind:
-    ...
-
-  @staticmethod
-  def FROM(that: multiplier.ir.Type) -> Optional[multiplier.ir.unsupported.UnsupportedType]:
-    ...
diff --git a/cmake/linker.cmake b/cmake/linker.cmake
index 3362e3cb4..05bf6e3fd 100644
--- a/cmake/linker.cmake
+++ b/cmake/linker.cmake
@@ -5,8 +5,6 @@
 # the LICENSE file found in the root directory of this source tree.
 #
 
-# MLIR requires that `lld` be used.
-
 if(PLATFORM_LINUX)
   set(CMAKE_EXE_LINKER_FLAGS_INIT "-fuse-ld=lld")
   set(CMAKE_MODULE_LINKER_FLAGS_INIT "-fuse-ld=lld")
diff --git a/cmake/mlir.cmake b/cmake/mlir.cmake
deleted file mode 100644
index 64206e70b..000000000
--- a/cmake/mlir.cmake
+++ /dev/null
@@ -1,51 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-if (MLIR_LINK_MLIR_DYLIB)
-  set(MLIR_LIBS MLIR)
-else()
-  get_property(MLIR_DIALECT_LIBS GLOBAL PROPERTY MLIR_DIALECT_LIBS)
-  get_property(MLIR_CONVERSION_LIBS GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
-  get_property(MLIR_EXTENSION_LIBS GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
-  get_property(MLIR_TRANSLATION_LIBS GLOBAL PROPERTY MLIR_TRANSLATION_LIBS)
-
-  set(MLIR_LIBS
-    MLIRAnalysis
-    MLIRDialect
-    MLIRExecutionEngine
-    MLIRIR
-    MLIRParser
-    MLIRPass
-    MLIRSupport
-    MLIRTransforms
-    MLIRTransformUtils
-    MLIRBytecodeReader
-    MLIRBytecodeWriter
-    MLIRBytecodeOpInterface
-
-    ${MLIR_DIALECT_LIBS}
-    ${MLIR_CONVERSION_LIBS}
-    ${MLIR_EXTENSION_LIBS}
-    ${MLIR_TRANSLATION_LIBS}
-  )
-
-  # `MLIR_DIR` is something like `<prefix>/lib/cmake/mlir`
-  cmake_path(GET MLIR_DIR PARENT_PATH lib_cmake_dir)
-  cmake_path(GET lib_cmake_dir PARENT_PATH lib_dir)
-
-  foreach(mlir_lib IN LISTS MLIR_LIBS)
-    find_library(mlir_lib_path "${mlir_lib}" HINTS "${lib_dir}" "${MX_VENDOR_INSTALL_DIR}/lib" "${MX_INSTALL_LIB_DIR}")
-    if (mlir_lib_path STREQUAL "mlir_lib_path-NOTFOUND")
-      message(FATAL_ERROR "Cannot locate MLIR library ${mlir_lib}")
-    endif()
-
-    cmake_path(GET mlir_lib_path PARENT_PATH MLIR_LIB_DIR)
-    break()
-  endforeach()
-
-  message(STATUS "Found MLIR libraries in ${MLIR_LIB_DIR}")
-endif()
\ No newline at end of file
diff --git a/cmake/vast.cmake b/cmake/vast.cmake
deleted file mode 100644
index 855112cad..000000000
--- a/cmake/vast.cmake
+++ /dev/null
@@ -1,19 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-set(VAST_LIBS
-  VAST::VASTTargetLLVMIR
-  VAST::VASTToLLVMConversionPasses
-  VAST::VASTAliasTypeInterface
-  VAST::VASTElementTypeInterface
-  VAST::VASTCodeGen
-  VAST::VASTFrontend
-  VAST::VASTSymbolInterface
-  VAST::VASTSymbolTableInterface
-  VAST::VASTSymbolRefInterface
-  VAST::VASTTypeDefinitionInterface
-)
diff --git a/docs/openssh-variant-analysis.md b/docs/openssh-variant-analysis.md
index 40d7d6262..29d85b05c 100644
--- a/docs/openssh-variant-analysis.md
+++ b/docs/openssh-variant-analysis.md
@@ -73,15 +73,12 @@ File serialization             (663 / 663)           100% [|||||||||||||||||||||
 AST partitioning               (237 / 237)           100% [||||||||||||||||||||||||||||||||||||||||]
 Fragment serialization         (30601 / 30601)       100% [||||||||||||||||||||||||||||||||||||||||]
 Type serialization             (18416 / 18416)       100% [||||||||||||||||||||||||||||||||||||||||]
-SourceIR                       (  0 / 237)             0% [                                        ]
 
 mx-index --db /tmp/openssh.db --workspace /tmp/openssh.ws --target    246.65s user 48.49s system 523% cpu 56.417 total
 ```
 
 Here we told `mx-index` to save its database to `/tmp/openssh.db` (we'll need this soon), and its temporary workspace to the directory `/tmp/openssh.ws`. We can now delete `/tmp/openssh.ws`, as its only needed if we wanted to index additional projects into the same database.
 
-The `--generate_sourceir` flag is optional if you plan to do the Python scripting. It will produce a lot more errors as output, but the indexer should finish.
-
 ```bash
 rm -rf /tmp/openssh.ws
 ```
diff --git a/docs/why-multiplier.md b/docs/why-multiplier.md
index f78d9f235..52cac2551 100644
--- a/docs/why-multiplier.md
+++ b/docs/why-multiplier.md
@@ -45,10 +45,9 @@ machine code located at different addresses. When you click on a call to
 Multiplier provides precise, and comprehensive code understanding capabilities
 by storing a compressed representation of build artifacts, called entities, in
 an index database. Entities in Multiplier's index include files, tokens, macro
-expansions, abstract syntax tree (AST) nodes, and compilations (represented with
-[MLIR](https://github.com/trailofbits/vast)). Each entity is uniquely identified
-by a 64 bit integer, and is available through scripting in C++ or
-[Python](https://www.python.org/) as a fully formed object with methods. For
+expansions, abstract syntax tree (AST) nodes, and compilations. Each entity is
+uniquely identified by a 64 bit integer, and is available through scripting in
+C++ or [Python](https://www.python.org/) as a fully formed object with methods. For
 example, the AST entities (declarations, statements, types, templates, etc.) are
 persistent forms of AST nodes found in [Clang](https://clang.llvm.org), and the
 methods available on these entities mirror those that can be called on those
diff --git a/include/multiplier/AST/AArch64SVEPcsAttr.h b/include/multiplier/AST/AArch64SVEPcsAttr.h
index e5afe5d90..4c9cde9ea 100644
--- a/include/multiplier/AST/AArch64SVEPcsAttr.h
+++ b/include/multiplier/AST/AArch64SVEPcsAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AArch64SVEPcsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AArch64VectorPcsAttr.h b/include/multiplier/AST/AArch64VectorPcsAttr.h
index 5fd432d6c..4ef385475 100644
--- a/include/multiplier/AST/AArch64VectorPcsAttr.h
+++ b/include/multiplier/AST/AArch64VectorPcsAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AArch64VectorPcsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AMDGPUFlatWorkGroupSizeAttr.h b/include/multiplier/AST/AMDGPUFlatWorkGroupSizeAttr.h
index 9d7ecd03f..e5f7e8810 100644
--- a/include/multiplier/AST/AMDGPUFlatWorkGroupSizeAttr.h
+++ b/include/multiplier/AST/AMDGPUFlatWorkGroupSizeAttr.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AMDGPUKernelCallAttr.h b/include/multiplier/AST/AMDGPUKernelCallAttr.h
index 7b820d7bd..d242549b0 100644
--- a/include/multiplier/AST/AMDGPUKernelCallAttr.h
+++ b/include/multiplier/AST/AMDGPUKernelCallAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AMDGPUKernelCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AMDGPUNumSGPRAttr.h b/include/multiplier/AST/AMDGPUNumSGPRAttr.h
index f1fee5666..5f38c2922 100644
--- a/include/multiplier/AST/AMDGPUNumSGPRAttr.h
+++ b/include/multiplier/AST/AMDGPUNumSGPRAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AMDGPUNumSGPRAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AMDGPUNumVGPRAttr.h b/include/multiplier/AST/AMDGPUNumVGPRAttr.h
index bdb68fdc0..c4085b389 100644
--- a/include/multiplier/AST/AMDGPUNumVGPRAttr.h
+++ b/include/multiplier/AST/AMDGPUNumVGPRAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AMDGPUNumVGPRAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AMDGPUWavesPerEUAttr.h b/include/multiplier/AST/AMDGPUWavesPerEUAttr.h
index f7d31d24e..3fa53c8e2 100644
--- a/include/multiplier/AST/AMDGPUWavesPerEUAttr.h
+++ b/include/multiplier/AST/AMDGPUWavesPerEUAttr.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AMDGPUWavesPerEUAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ARMInterruptAttr.h b/include/multiplier/AST/ARMInterruptAttr.h
index 209cfd56d..9d06ec4d2 100644
--- a/include/multiplier/AST/ARMInterruptAttr.h
+++ b/include/multiplier/AST/ARMInterruptAttr.h
@@ -19,11 +19,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ARMInterruptAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AVRInterruptAttr.h b/include/multiplier/AST/AVRInterruptAttr.h
index 4d660ab56..8d2fb4aa3 100644
--- a/include/multiplier/AST/AVRInterruptAttr.h
+++ b/include/multiplier/AST/AVRInterruptAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AVRInterruptAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AVRSignalAttr.h b/include/multiplier/AST/AVRSignalAttr.h
index 653296aa9..b5f98c15a 100644
--- a/include/multiplier/AST/AVRSignalAttr.h
+++ b/include/multiplier/AST/AVRSignalAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AVRSignalAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AbiTagAttr.h b/include/multiplier/AST/AbiTagAttr.h
index b6258b0a0..b67f2ac20 100644
--- a/include/multiplier/AST/AbiTagAttr.h
+++ b/include/multiplier/AST/AbiTagAttr.h
@@ -17,11 +17,6 @@ class AbiTagAttr;
 class Attr;
 class File;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AbiTagAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/AbstractConditionalOperator.h b/include/multiplier/AST/AbstractConditionalOperator.h
index 3b12f146f..2395b9cfc 100644
--- a/include/multiplier/AST/AbstractConditionalOperator.h
+++ b/include/multiplier/AST/AbstractConditionalOperator.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AbstractConditionalOperator : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT AbstractConditionalOperator : public Expr {
   static gap::generator<AbstractConditionalOperator> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<AbstractConditionalOperator> from(const ir::Operation &op);
-  static gap::generator<std::pair<AbstractConditionalOperator, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<AbstractConditionalOperator> in(const Compilation &tu);
   static gap::generator<AbstractConditionalOperator> containing(const Decl &decl);
   static gap::generator<AbstractConditionalOperator> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/AccessSpecDecl.h b/include/multiplier/AST/AccessSpecDecl.h
index 0f6d072aa..52de15911 100644
--- a/include/multiplier/AST/AccessSpecDecl.h
+++ b/include/multiplier/AST/AccessSpecDecl.h
@@ -18,11 +18,6 @@ class Decl;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AccessSpecDecl : public Decl {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT AccessSpecDecl : public Decl {
   static gap::generator<AccessSpecDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<AccessSpecDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<AccessSpecDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<AccessSpecDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::ACCESS_SPEC;
   }
diff --git a/include/multiplier/AST/AcquireCapabilityAttr.h b/include/multiplier/AST/AcquireCapabilityAttr.h
index d9f77ff34..1000b7337 100644
--- a/include/multiplier/AST/AcquireCapabilityAttr.h
+++ b/include/multiplier/AST/AcquireCapabilityAttr.h
@@ -19,11 +19,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AcquireCapabilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AcquireHandleAttr.h b/include/multiplier/AST/AcquireHandleAttr.h
index e5f65721b..99a3833da 100644
--- a/include/multiplier/AST/AcquireHandleAttr.h
+++ b/include/multiplier/AST/AcquireHandleAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AcquireHandleAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AcquiredAfterAttr.h b/include/multiplier/AST/AcquiredAfterAttr.h
index f044d46ff..81815c2a0 100644
--- a/include/multiplier/AST/AcquiredAfterAttr.h
+++ b/include/multiplier/AST/AcquiredAfterAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AcquiredAfterAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AcquiredBeforeAttr.h b/include/multiplier/AST/AcquiredBeforeAttr.h
index d8eda7017..7ce337146 100644
--- a/include/multiplier/AST/AcquiredBeforeAttr.h
+++ b/include/multiplier/AST/AcquiredBeforeAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AcquiredBeforeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AddrLabelExpr.h b/include/multiplier/AST/AddrLabelExpr.h
index d1df3522c..086f63e08 100644
--- a/include/multiplier/AST/AddrLabelExpr.h
+++ b/include/multiplier/AST/AddrLabelExpr.h
@@ -21,11 +21,6 @@ class LabelDecl;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AddrLabelExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT AddrLabelExpr : public Expr {
   static gap::generator<AddrLabelExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<AddrLabelExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<AddrLabelExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<AddrLabelExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::ADDR_LABEL_EXPR;
   }
diff --git a/include/multiplier/AST/AddressSpaceAttr.h b/include/multiplier/AST/AddressSpaceAttr.h
index 1e6b2d676..4b5ed9a2a 100644
--- a/include/multiplier/AST/AddressSpaceAttr.h
+++ b/include/multiplier/AST/AddressSpaceAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AddressSpaceAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/AdjustedType.h b/include/multiplier/AST/AdjustedType.h
index 52d71379d..83196e207 100644
--- a/include/multiplier/AST/AdjustedType.h
+++ b/include/multiplier/AST/AdjustedType.h
@@ -16,11 +16,6 @@ class Index;
 class AdjustedType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AdjustedType : public Type {
  private:
diff --git a/include/multiplier/AST/AliasAttr.h b/include/multiplier/AST/AliasAttr.h
index 0b0c89633..b7b9f7ecd 100644
--- a/include/multiplier/AST/AliasAttr.h
+++ b/include/multiplier/AST/AliasAttr.h
@@ -17,11 +17,6 @@ class AliasAttr;
 class Attr;
 class File;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AliasAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/AlignMac68kAttr.h b/include/multiplier/AST/AlignMac68kAttr.h
index 2404db44b..f9deacf8c 100644
--- a/include/multiplier/AST/AlignMac68kAttr.h
+++ b/include/multiplier/AST/AlignMac68kAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AlignMac68kAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AlignNaturalAttr.h b/include/multiplier/AST/AlignNaturalAttr.h
index e18140609..4a9efaa23 100644
--- a/include/multiplier/AST/AlignNaturalAttr.h
+++ b/include/multiplier/AST/AlignNaturalAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AlignNaturalAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AlignValueAttr.h b/include/multiplier/AST/AlignValueAttr.h
index 6427a91d5..b052d7118 100644
--- a/include/multiplier/AST/AlignValueAttr.h
+++ b/include/multiplier/AST/AlignValueAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class Expr;
 class File;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AlignValueAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/AlignedAttr.h b/include/multiplier/AST/AlignedAttr.h
index 7ef3dfd35..3b443cf1d 100644
--- a/include/multiplier/AST/AlignedAttr.h
+++ b/include/multiplier/AST/AlignedAttr.h
@@ -21,11 +21,6 @@ class File;
 class InheritableAttr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AlignedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AllocAlignAttr.h b/include/multiplier/AST/AllocAlignAttr.h
index 3d65bc2f0..f4815dfba 100644
--- a/include/multiplier/AST/AllocAlignAttr.h
+++ b/include/multiplier/AST/AllocAlignAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AllocAlignAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AllocSizeAttr.h b/include/multiplier/AST/AllocSizeAttr.h
index 4af8f4f21..b490e1428 100644
--- a/include/multiplier/AST/AllocSizeAttr.h
+++ b/include/multiplier/AST/AllocSizeAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AllocSizeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AlwaysDestroyAttr.h b/include/multiplier/AST/AlwaysDestroyAttr.h
index ebb78f6cd..17928d1d3 100644
--- a/include/multiplier/AST/AlwaysDestroyAttr.h
+++ b/include/multiplier/AST/AlwaysDestroyAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AlwaysDestroyAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AlwaysInlineAttr.h b/include/multiplier/AST/AlwaysInlineAttr.h
index a6a6ea934..2691d2b6d 100644
--- a/include/multiplier/AST/AlwaysInlineAttr.h
+++ b/include/multiplier/AST/AlwaysInlineAttr.h
@@ -20,11 +20,6 @@ class DeclOrStmtAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AlwaysInlineAttr : public DeclOrStmtAttr {
  private:
diff --git a/include/multiplier/AST/AnalyzerNoReturnAttr.h b/include/multiplier/AST/AnalyzerNoReturnAttr.h
index 715d72771..71aad5164 100644
--- a/include/multiplier/AST/AnalyzerNoReturnAttr.h
+++ b/include/multiplier/AST/AnalyzerNoReturnAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AnalyzerNoReturnAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AnnotateAttr.h b/include/multiplier/AST/AnnotateAttr.h
index 2435bc2e1..91a9294b6 100644
--- a/include/multiplier/AST/AnnotateAttr.h
+++ b/include/multiplier/AST/AnnotateAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class InheritableParamAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AnnotateAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/AnnotateTypeAttr.h b/include/multiplier/AST/AnnotateTypeAttr.h
index 4146016b0..60c8aa329 100644
--- a/include/multiplier/AST/AnnotateTypeAttr.h
+++ b/include/multiplier/AST/AnnotateTypeAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AnnotateTypeAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/AnyX86InterruptAttr.h b/include/multiplier/AST/AnyX86InterruptAttr.h
index 6d97a3ee6..89eb5298f 100644
--- a/include/multiplier/AST/AnyX86InterruptAttr.h
+++ b/include/multiplier/AST/AnyX86InterruptAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AnyX86InterruptAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AnyX86NoCallerSavedRegistersAttr.h b/include/multiplier/AST/AnyX86NoCallerSavedRegistersAttr.h
index 19863adb5..0f674c08b 100644
--- a/include/multiplier/AST/AnyX86NoCallerSavedRegistersAttr.h
+++ b/include/multiplier/AST/AnyX86NoCallerSavedRegistersAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AnyX86NoCallerSavedRegistersAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AnyX86NoCfCheckAttr.h b/include/multiplier/AST/AnyX86NoCfCheckAttr.h
index 6a811f3ca..f69510c4b 100644
--- a/include/multiplier/AST/AnyX86NoCfCheckAttr.h
+++ b/include/multiplier/AST/AnyX86NoCfCheckAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AnyX86NoCfCheckAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ArcWeakrefUnavailableAttr.h b/include/multiplier/AST/ArcWeakrefUnavailableAttr.h
index ba3c830b3..c03831fd5 100644
--- a/include/multiplier/AST/ArcWeakrefUnavailableAttr.h
+++ b/include/multiplier/AST/ArcWeakrefUnavailableAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArcWeakrefUnavailableAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ArgumentWithTypeTagAttr.h b/include/multiplier/AST/ArgumentWithTypeTagAttr.h
index 29ea85212..b1d37b56a 100644
--- a/include/multiplier/AST/ArgumentWithTypeTagAttr.h
+++ b/include/multiplier/AST/ArgumentWithTypeTagAttr.h
@@ -19,11 +19,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArgumentWithTypeTagAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ArmBuiltinAliasAttr.h b/include/multiplier/AST/ArmBuiltinAliasAttr.h
index c49c11a21..959076be5 100644
--- a/include/multiplier/AST/ArmBuiltinAliasAttr.h
+++ b/include/multiplier/AST/ArmBuiltinAliasAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmBuiltinAliasAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ArmInAttr.h b/include/multiplier/AST/ArmInAttr.h
index 4bb59f81f..2e5ff1208 100644
--- a/include/multiplier/AST/ArmInAttr.h
+++ b/include/multiplier/AST/ArmInAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmInAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ArmInOutAttr.h b/include/multiplier/AST/ArmInOutAttr.h
index e395a95a8..494224926 100644
--- a/include/multiplier/AST/ArmInOutAttr.h
+++ b/include/multiplier/AST/ArmInOutAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmInOutAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ArmLocallyStreamingAttr.h b/include/multiplier/AST/ArmLocallyStreamingAttr.h
index d85da7405..62311b620 100644
--- a/include/multiplier/AST/ArmLocallyStreamingAttr.h
+++ b/include/multiplier/AST/ArmLocallyStreamingAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmLocallyStreamingAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ArmMveStrictPolymorphismAttr.h b/include/multiplier/AST/ArmMveStrictPolymorphismAttr.h
index 3c70f33a3..26e752ea5 100644
--- a/include/multiplier/AST/ArmMveStrictPolymorphismAttr.h
+++ b/include/multiplier/AST/ArmMveStrictPolymorphismAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmMveStrictPolymorphismAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ArmNewAttr.h b/include/multiplier/AST/ArmNewAttr.h
index 747129b52..665daf06e 100644
--- a/include/multiplier/AST/ArmNewAttr.h
+++ b/include/multiplier/AST/ArmNewAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmNewAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ArmOutAttr.h b/include/multiplier/AST/ArmOutAttr.h
index 4d6566019..adb0b37d8 100644
--- a/include/multiplier/AST/ArmOutAttr.h
+++ b/include/multiplier/AST/ArmOutAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmOutAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ArmPreservesAttr.h b/include/multiplier/AST/ArmPreservesAttr.h
index b278d6fec..d2e9454af 100644
--- a/include/multiplier/AST/ArmPreservesAttr.h
+++ b/include/multiplier/AST/ArmPreservesAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmPreservesAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ArmStreamingAttr.h b/include/multiplier/AST/ArmStreamingAttr.h
index f0685e06a..115512fab 100644
--- a/include/multiplier/AST/ArmStreamingAttr.h
+++ b/include/multiplier/AST/ArmStreamingAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmStreamingAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ArmStreamingCompatibleAttr.h b/include/multiplier/AST/ArmStreamingCompatibleAttr.h
index 9819dcda7..603a57e73 100644
--- a/include/multiplier/AST/ArmStreamingCompatibleAttr.h
+++ b/include/multiplier/AST/ArmStreamingCompatibleAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArmStreamingCompatibleAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ArrayInitIndexExpr.h b/include/multiplier/AST/ArrayInitIndexExpr.h
index 6de11c998..bebb79731 100644
--- a/include/multiplier/AST/ArrayInitIndexExpr.h
+++ b/include/multiplier/AST/ArrayInitIndexExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArrayInitIndexExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ArrayInitIndexExpr : public Expr {
   static gap::generator<ArrayInitIndexExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ArrayInitIndexExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ArrayInitIndexExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ArrayInitIndexExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::ARRAY_INIT_INDEX_EXPR;
   }
diff --git a/include/multiplier/AST/ArrayInitLoopExpr.h b/include/multiplier/AST/ArrayInitLoopExpr.h
index ddb753db8..d0cb100bf 100644
--- a/include/multiplier/AST/ArrayInitLoopExpr.h
+++ b/include/multiplier/AST/ArrayInitLoopExpr.h
@@ -21,11 +21,6 @@ class OpaqueValueExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArrayInitLoopExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ArrayInitLoopExpr : public Expr {
   static gap::generator<ArrayInitLoopExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ArrayInitLoopExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ArrayInitLoopExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ArrayInitLoopExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::ARRAY_INIT_LOOP_EXPR;
   }
diff --git a/include/multiplier/AST/ArraySubscriptExpr.h b/include/multiplier/AST/ArraySubscriptExpr.h
index 984d965a2..22693f213 100644
--- a/include/multiplier/AST/ArraySubscriptExpr.h
+++ b/include/multiplier/AST/ArraySubscriptExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArraySubscriptExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ArraySubscriptExpr : public Expr {
   static gap::generator<ArraySubscriptExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ArraySubscriptExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ArraySubscriptExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ArraySubscriptExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::ARRAY_SUBSCRIPT_EXPR;
   }
diff --git a/include/multiplier/AST/ArrayType.h b/include/multiplier/AST/ArrayType.h
index 2af139118..e249ab320 100644
--- a/include/multiplier/AST/ArrayType.h
+++ b/include/multiplier/AST/ArrayType.h
@@ -17,11 +17,6 @@ class Index;
 class ArrayType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArrayType : public Type {
  private:
diff --git a/include/multiplier/AST/ArrayTypeTraitExpr.h b/include/multiplier/AST/ArrayTypeTraitExpr.h
index a2ae4d2da..910a02ee4 100644
--- a/include/multiplier/AST/ArrayTypeTraitExpr.h
+++ b/include/multiplier/AST/ArrayTypeTraitExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArrayTypeTraitExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT ArrayTypeTraitExpr : public Expr {
   static gap::generator<ArrayTypeTraitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ArrayTypeTraitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ArrayTypeTraitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ArrayTypeTraitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::ARRAY_TYPE_TRAIT_EXPR;
   }
diff --git a/include/multiplier/AST/ArtificialAttr.h b/include/multiplier/AST/ArtificialAttr.h
index 88cdafef4..66f7c126f 100644
--- a/include/multiplier/AST/ArtificialAttr.h
+++ b/include/multiplier/AST/ArtificialAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ArtificialAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AsTypeExpr.h b/include/multiplier/AST/AsTypeExpr.h
index d0cc1680f..2cd9b8374 100644
--- a/include/multiplier/AST/AsTypeExpr.h
+++ b/include/multiplier/AST/AsTypeExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AsTypeExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT AsTypeExpr : public Expr {
   static gap::generator<AsTypeExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<AsTypeExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<AsTypeExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<AsTypeExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::AS_TYPE_EXPR;
   }
diff --git a/include/multiplier/AST/AsmLabelAttr.h b/include/multiplier/AST/AsmLabelAttr.h
index bea827ed6..f71664c94 100644
--- a/include/multiplier/AST/AsmLabelAttr.h
+++ b/include/multiplier/AST/AsmLabelAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AsmLabelAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AsmStmt.h b/include/multiplier/AST/AsmStmt.h
index 760ec196c..b303a2669 100644
--- a/include/multiplier/AST/AsmStmt.h
+++ b/include/multiplier/AST/AsmStmt.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AsmStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT AsmStmt : public Stmt {
   static gap::generator<AsmStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<AsmStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<AsmStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<AsmStmt> in(const Compilation &tu);
   static gap::generator<AsmStmt> containing(const Decl &decl);
   static gap::generator<AsmStmt> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/AssertCapabilityAttr.h b/include/multiplier/AST/AssertCapabilityAttr.h
index 38e3da3a8..979431d0c 100644
--- a/include/multiplier/AST/AssertCapabilityAttr.h
+++ b/include/multiplier/AST/AssertCapabilityAttr.h
@@ -19,11 +19,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AssertCapabilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AssertExclusiveLockAttr.h b/include/multiplier/AST/AssertExclusiveLockAttr.h
index caf06d993..785075aec 100644
--- a/include/multiplier/AST/AssertExclusiveLockAttr.h
+++ b/include/multiplier/AST/AssertExclusiveLockAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AssertExclusiveLockAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AssertSharedLockAttr.h b/include/multiplier/AST/AssertSharedLockAttr.h
index 477b3b218..0edcadf36 100644
--- a/include/multiplier/AST/AssertSharedLockAttr.h
+++ b/include/multiplier/AST/AssertSharedLockAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AssertSharedLockAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AssumeAlignedAttr.h b/include/multiplier/AST/AssumeAlignedAttr.h
index 54838f64c..51c86d1bc 100644
--- a/include/multiplier/AST/AssumeAlignedAttr.h
+++ b/include/multiplier/AST/AssumeAlignedAttr.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AssumeAlignedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AssumptionAttr.h b/include/multiplier/AST/AssumptionAttr.h
index d6be18087..a191df41b 100644
--- a/include/multiplier/AST/AssumptionAttr.h
+++ b/include/multiplier/AST/AssumptionAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AssumptionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AtomicExpr.h b/include/multiplier/AST/AtomicExpr.h
index 06f728936..a2023a713 100644
--- a/include/multiplier/AST/AtomicExpr.h
+++ b/include/multiplier/AST/AtomicExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AtomicExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT AtomicExpr : public Expr {
   static gap::generator<AtomicExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<AtomicExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<AtomicExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<AtomicExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::ATOMIC_EXPR;
   }
diff --git a/include/multiplier/AST/AtomicType.h b/include/multiplier/AST/AtomicType.h
index aa639537c..9ef6c44f3 100644
--- a/include/multiplier/AST/AtomicType.h
+++ b/include/multiplier/AST/AtomicType.h
@@ -16,11 +16,6 @@ class Index;
 class AtomicType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AtomicType : public Type {
  private:
diff --git a/include/multiplier/AST/Attr.h b/include/multiplier/AST/Attr.h
index 820f5d40c..3e3771708 100644
--- a/include/multiplier/AST/Attr.h
+++ b/include/multiplier/AST/Attr.h
@@ -33,11 +33,6 @@ class AttrImpl;
 class File;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT Attr {
  public:
@@ -55,8 +50,7 @@ class MX_EXPORT Attr {
   friend class TokenContext;
   friend class Type;
   friend class AttrImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const AttrImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
diff --git a/include/multiplier/AST/AttributedStmt.h b/include/multiplier/AST/AttributedStmt.h
index 4e73119d8..3dbaaa1f3 100644
--- a/include/multiplier/AST/AttributedStmt.h
+++ b/include/multiplier/AST/AttributedStmt.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AttributedStmt : public ValueStmt {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT AttributedStmt : public ValueStmt {
   static gap::generator<AttributedStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<AttributedStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<AttributedStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<AttributedStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::ATTRIBUTED_STMT;
   }
diff --git a/include/multiplier/AST/AttributedType.h b/include/multiplier/AST/AttributedType.h
index d0f1fae43..ae2edada5 100644
--- a/include/multiplier/AST/AttributedType.h
+++ b/include/multiplier/AST/AttributedType.h
@@ -19,11 +19,6 @@ class Attr;
 class AttributedType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AttributedType : public Type {
  private:
diff --git a/include/multiplier/AST/AutoType.h b/include/multiplier/AST/AutoType.h
index 84ecde660..f9f31be88 100644
--- a/include/multiplier/AST/AutoType.h
+++ b/include/multiplier/AST/AutoType.h
@@ -20,11 +20,6 @@ class DeducedType;
 class TemplateArgument;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AutoType : public DeducedType {
  private:
diff --git a/include/multiplier/AST/AvailabilityAttr.h b/include/multiplier/AST/AvailabilityAttr.h
index 6f9abad95..839578935 100644
--- a/include/multiplier/AST/AvailabilityAttr.h
+++ b/include/multiplier/AST/AvailabilityAttr.h
@@ -18,11 +18,6 @@ class AvailabilityAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AvailabilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/AvailableOnlyInDefaultEvalMethodAttr.h b/include/multiplier/AST/AvailableOnlyInDefaultEvalMethodAttr.h
index 4760cb4e1..d2ef74a86 100644
--- a/include/multiplier/AST/AvailableOnlyInDefaultEvalMethodAttr.h
+++ b/include/multiplier/AST/AvailableOnlyInDefaultEvalMethodAttr.h
@@ -18,11 +18,6 @@ class AvailableOnlyInDefaultEvalMethodAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT AvailableOnlyInDefaultEvalMethodAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/BPFPreserveAccessIndexAttr.h b/include/multiplier/AST/BPFPreserveAccessIndexAttr.h
index 7a4019882..18693008f 100644
--- a/include/multiplier/AST/BPFPreserveAccessIndexAttr.h
+++ b/include/multiplier/AST/BPFPreserveAccessIndexAttr.h
@@ -18,11 +18,6 @@ class BPFPreserveAccessIndexAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BPFPreserveAccessIndexAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/BPFPreserveStaticOffsetAttr.h b/include/multiplier/AST/BPFPreserveStaticOffsetAttr.h
index aeac1c5c6..3f0960c97 100644
--- a/include/multiplier/AST/BPFPreserveStaticOffsetAttr.h
+++ b/include/multiplier/AST/BPFPreserveStaticOffsetAttr.h
@@ -18,11 +18,6 @@ class BPFPreserveStaticOffsetAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BPFPreserveStaticOffsetAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/BTFDeclTagAttr.h b/include/multiplier/AST/BTFDeclTagAttr.h
index e5f7019d3..14fe5778e 100644
--- a/include/multiplier/AST/BTFDeclTagAttr.h
+++ b/include/multiplier/AST/BTFDeclTagAttr.h
@@ -18,11 +18,6 @@ class BTFDeclTagAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BTFDeclTagAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/BTFTagAttributedType.h b/include/multiplier/AST/BTFTagAttributedType.h
index 4b5578d3e..d456039f9 100644
--- a/include/multiplier/AST/BTFTagAttributedType.h
+++ b/include/multiplier/AST/BTFTagAttributedType.h
@@ -17,11 +17,6 @@ class BTFTagAttributedType;
 class BTFTypeTagAttr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BTFTagAttributedType : public Type {
  private:
diff --git a/include/multiplier/AST/BTFTypeTagAttr.h b/include/multiplier/AST/BTFTypeTagAttr.h
index 6201e97c7..3b6211ef9 100644
--- a/include/multiplier/AST/BTFTypeTagAttr.h
+++ b/include/multiplier/AST/BTFTypeTagAttr.h
@@ -18,11 +18,6 @@ class BTFTypeTagAttr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BTFTypeTagAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/BaseUsingDecl.h b/include/multiplier/AST/BaseUsingDecl.h
index 776ee827f..eb6671404 100644
--- a/include/multiplier/AST/BaseUsingDecl.h
+++ b/include/multiplier/AST/BaseUsingDecl.h
@@ -20,11 +20,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class UsingShadowDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BaseUsingDecl : public NamedDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT BaseUsingDecl : public NamedDecl {
   static gap::generator<BaseUsingDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<BaseUsingDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<BaseUsingDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<BaseUsingDecl> in(const Compilation &tu);
   static gap::generator<BaseUsingDecl> containing(const Decl &decl);
   static gap::generator<BaseUsingDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/BinaryConditionalOperator.h b/include/multiplier/AST/BinaryConditionalOperator.h
index eaff7eb9c..9bb1c8575 100644
--- a/include/multiplier/AST/BinaryConditionalOperator.h
+++ b/include/multiplier/AST/BinaryConditionalOperator.h
@@ -22,11 +22,6 @@ class OpaqueValueExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BinaryConditionalOperator : public AbstractConditionalOperator {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT BinaryConditionalOperator : public AbstractConditionalOperator {
   static gap::generator<BinaryConditionalOperator> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<BinaryConditionalOperator> from(const ir::Operation &op);
-  static gap::generator<std::pair<BinaryConditionalOperator, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<BinaryConditionalOperator> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::BINARY_CONDITIONAL_OPERATOR;
   }
diff --git a/include/multiplier/AST/BinaryOperator.h b/include/multiplier/AST/BinaryOperator.h
index 3075397ce..3d898feba 100644
--- a/include/multiplier/AST/BinaryOperator.h
+++ b/include/multiplier/AST/BinaryOperator.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BinaryOperator : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT BinaryOperator : public Expr {
   static gap::generator<BinaryOperator> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<BinaryOperator> from(const ir::Operation &op);
-  static gap::generator<std::pair<BinaryOperator, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<BinaryOperator> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::BINARY_OPERATOR;
   }
diff --git a/include/multiplier/AST/BindingDecl.h b/include/multiplier/AST/BindingDecl.h
index 5147d5174..c374c9b70 100644
--- a/include/multiplier/AST/BindingDecl.h
+++ b/include/multiplier/AST/BindingDecl.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class ValueDecl;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BindingDecl : public ValueDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT BindingDecl : public ValueDecl {
   static gap::generator<BindingDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<BindingDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<BindingDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<BindingDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::BINDING;
   }
diff --git a/include/multiplier/AST/BitIntType.h b/include/multiplier/AST/BitIntType.h
index eff625ba9..d3d14d931 100644
--- a/include/multiplier/AST/BitIntType.h
+++ b/include/multiplier/AST/BitIntType.h
@@ -16,11 +16,6 @@ class Index;
 class BitIntType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BitIntType : public Type {
  private:
diff --git a/include/multiplier/AST/BlockDecl.h b/include/multiplier/AST/BlockDecl.h
index be92f05ff..37d21c2ce 100644
--- a/include/multiplier/AST/BlockDecl.h
+++ b/include/multiplier/AST/BlockDecl.h
@@ -22,11 +22,6 @@ class ParmVarDecl;
 class Stmt;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BlockDecl : public Decl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT BlockDecl : public Decl {
   static gap::generator<BlockDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<BlockDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<BlockDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<BlockDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::BLOCK;
   }
diff --git a/include/multiplier/AST/BlockExpr.h b/include/multiplier/AST/BlockExpr.h
index 88948372c..768dc4363 100644
--- a/include/multiplier/AST/BlockExpr.h
+++ b/include/multiplier/AST/BlockExpr.h
@@ -22,11 +22,6 @@ class FunctionProtoType;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BlockExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT BlockExpr : public Expr {
   static gap::generator<BlockExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<BlockExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<BlockExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<BlockExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::BLOCK_EXPR;
   }
diff --git a/include/multiplier/AST/BlockPointerType.h b/include/multiplier/AST/BlockPointerType.h
index 8de3161b7..30dea5605 100644
--- a/include/multiplier/AST/BlockPointerType.h
+++ b/include/multiplier/AST/BlockPointerType.h
@@ -16,11 +16,6 @@ class Index;
 class BlockPointerType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BlockPointerType : public Type {
  private:
diff --git a/include/multiplier/AST/BlocksAttr.h b/include/multiplier/AST/BlocksAttr.h
index b39f63a26..d5b1a4045 100644
--- a/include/multiplier/AST/BlocksAttr.h
+++ b/include/multiplier/AST/BlocksAttr.h
@@ -19,11 +19,6 @@ class BlocksAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BlocksAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/BreakStmt.h b/include/multiplier/AST/BreakStmt.h
index 01da2eb1e..6a205b4b0 100644
--- a/include/multiplier/AST/BreakStmt.h
+++ b/include/multiplier/AST/BreakStmt.h
@@ -18,11 +18,6 @@ class Decl;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BreakStmt : public Stmt {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT BreakStmt : public Stmt {
   static gap::generator<BreakStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<BreakStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<BreakStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<BreakStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::BREAK_STMT;
   }
diff --git a/include/multiplier/AST/BuiltinAliasAttr.h b/include/multiplier/AST/BuiltinAliasAttr.h
index 9961596c5..c3071f1a9 100644
--- a/include/multiplier/AST/BuiltinAliasAttr.h
+++ b/include/multiplier/AST/BuiltinAliasAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class BuiltinAliasAttr;
 class File;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BuiltinAliasAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/BuiltinAttr.h b/include/multiplier/AST/BuiltinAttr.h
index 2107c30c3..fa3bab06f 100644
--- a/include/multiplier/AST/BuiltinAttr.h
+++ b/include/multiplier/AST/BuiltinAttr.h
@@ -18,11 +18,6 @@ class BuiltinAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BuiltinAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/BuiltinBitCastExpr.h b/include/multiplier/AST/BuiltinBitCastExpr.h
index ff40fc1e8..1d0f131dc 100644
--- a/include/multiplier/AST/BuiltinBitCastExpr.h
+++ b/include/multiplier/AST/BuiltinBitCastExpr.h
@@ -22,11 +22,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BuiltinBitCastExpr : public ExplicitCastExpr {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT BuiltinBitCastExpr : public ExplicitCastExpr {
   static gap::generator<BuiltinBitCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<BuiltinBitCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<BuiltinBitCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<BuiltinBitCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::BUILTIN_BIT_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/BuiltinTemplateDecl.h b/include/multiplier/AST/BuiltinTemplateDecl.h
index 3531c6695..71be24b78 100644
--- a/include/multiplier/AST/BuiltinTemplateDecl.h
+++ b/include/multiplier/AST/BuiltinTemplateDecl.h
@@ -20,11 +20,6 @@ class NamedDecl;
 class Stmt;
 class TemplateDecl;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BuiltinTemplateDecl : public TemplateDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT BuiltinTemplateDecl : public TemplateDecl {
   static gap::generator<BuiltinTemplateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<BuiltinTemplateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<BuiltinTemplateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<BuiltinTemplateDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::BUILTIN_TEMPLATE;
   }
diff --git a/include/multiplier/AST/BuiltinType.h b/include/multiplier/AST/BuiltinType.h
index 06d121434..3c705951c 100644
--- a/include/multiplier/AST/BuiltinType.h
+++ b/include/multiplier/AST/BuiltinType.h
@@ -17,11 +17,6 @@ class Index;
 class BuiltinType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT BuiltinType : public Type {
  private:
diff --git a/include/multiplier/AST/C11NoReturnAttr.h b/include/multiplier/AST/C11NoReturnAttr.h
index db013e601..4c4065575 100644
--- a/include/multiplier/AST/C11NoReturnAttr.h
+++ b/include/multiplier/AST/C11NoReturnAttr.h
@@ -18,11 +18,6 @@ class C11NoReturnAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT C11NoReturnAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CDeclAttr.h b/include/multiplier/AST/CDeclAttr.h
index d2bf005f6..5f1753e14 100644
--- a/include/multiplier/AST/CDeclAttr.h
+++ b/include/multiplier/AST/CDeclAttr.h
@@ -18,11 +18,6 @@ class CDeclAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CDeclAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CFAuditedTransferAttr.h b/include/multiplier/AST/CFAuditedTransferAttr.h
index e03e55055..1a0a6f46c 100644
--- a/include/multiplier/AST/CFAuditedTransferAttr.h
+++ b/include/multiplier/AST/CFAuditedTransferAttr.h
@@ -18,11 +18,6 @@ class CFAuditedTransferAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CFAuditedTransferAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CFConsumedAttr.h b/include/multiplier/AST/CFConsumedAttr.h
index 235e4c913..f4773ad48 100644
--- a/include/multiplier/AST/CFConsumedAttr.h
+++ b/include/multiplier/AST/CFConsumedAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class InheritableParamAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CFConsumedAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/CFGuardAttr.h b/include/multiplier/AST/CFGuardAttr.h
index 641b70b28..353e4b560 100644
--- a/include/multiplier/AST/CFGuardAttr.h
+++ b/include/multiplier/AST/CFGuardAttr.h
@@ -19,11 +19,6 @@ class CFGuardAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CFGuardAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CFICanonicalJumpTableAttr.h b/include/multiplier/AST/CFICanonicalJumpTableAttr.h
index d8d6c1eff..48e918d07 100644
--- a/include/multiplier/AST/CFICanonicalJumpTableAttr.h
+++ b/include/multiplier/AST/CFICanonicalJumpTableAttr.h
@@ -18,11 +18,6 @@ class CFICanonicalJumpTableAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CFICanonicalJumpTableAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CFReturnsNotRetainedAttr.h b/include/multiplier/AST/CFReturnsNotRetainedAttr.h
index 026a41aa1..83bb83875 100644
--- a/include/multiplier/AST/CFReturnsNotRetainedAttr.h
+++ b/include/multiplier/AST/CFReturnsNotRetainedAttr.h
@@ -18,11 +18,6 @@ class CFReturnsNotRetainedAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CFReturnsNotRetainedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CFReturnsRetainedAttr.h b/include/multiplier/AST/CFReturnsRetainedAttr.h
index e01a7af66..c1d0412b9 100644
--- a/include/multiplier/AST/CFReturnsRetainedAttr.h
+++ b/include/multiplier/AST/CFReturnsRetainedAttr.h
@@ -18,11 +18,6 @@ class CFReturnsRetainedAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CFReturnsRetainedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CFUnknownTransferAttr.h b/include/multiplier/AST/CFUnknownTransferAttr.h
index 04246ce59..db184a78e 100644
--- a/include/multiplier/AST/CFUnknownTransferAttr.h
+++ b/include/multiplier/AST/CFUnknownTransferAttr.h
@@ -18,11 +18,6 @@ class CFUnknownTransferAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CFUnknownTransferAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CPUDispatchAttr.h b/include/multiplier/AST/CPUDispatchAttr.h
index 8fb9107db..35a048daa 100644
--- a/include/multiplier/AST/CPUDispatchAttr.h
+++ b/include/multiplier/AST/CPUDispatchAttr.h
@@ -18,11 +18,6 @@ class CPUDispatchAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CPUDispatchAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CPUSpecificAttr.h b/include/multiplier/AST/CPUSpecificAttr.h
index e2a13b93e..5a0d271a6 100644
--- a/include/multiplier/AST/CPUSpecificAttr.h
+++ b/include/multiplier/AST/CPUSpecificAttr.h
@@ -18,11 +18,6 @@ class CPUSpecificAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CPUSpecificAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CStyleCastExpr.h b/include/multiplier/AST/CStyleCastExpr.h
index cb83ef561..a11944d2d 100644
--- a/include/multiplier/AST/CStyleCastExpr.h
+++ b/include/multiplier/AST/CStyleCastExpr.h
@@ -22,11 +22,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CStyleCastExpr : public ExplicitCastExpr {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT CStyleCastExpr : public ExplicitCastExpr {
   static gap::generator<CStyleCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CStyleCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CStyleCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CStyleCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::C_STYLE_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/CUDAConstantAttr.h b/include/multiplier/AST/CUDAConstantAttr.h
index 841b414bc..e36ac99fd 100644
--- a/include/multiplier/AST/CUDAConstantAttr.h
+++ b/include/multiplier/AST/CUDAConstantAttr.h
@@ -18,11 +18,6 @@ class CUDAConstantAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDAConstantAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CUDADeviceAttr.h b/include/multiplier/AST/CUDADeviceAttr.h
index a68dacb51..491a81599 100644
--- a/include/multiplier/AST/CUDADeviceAttr.h
+++ b/include/multiplier/AST/CUDADeviceAttr.h
@@ -18,11 +18,6 @@ class CUDADeviceAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDADeviceAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CUDADeviceBuiltinSurfaceTypeAttr.h b/include/multiplier/AST/CUDADeviceBuiltinSurfaceTypeAttr.h
index 665844f44..e610ebaae 100644
--- a/include/multiplier/AST/CUDADeviceBuiltinSurfaceTypeAttr.h
+++ b/include/multiplier/AST/CUDADeviceBuiltinSurfaceTypeAttr.h
@@ -18,11 +18,6 @@ class CUDADeviceBuiltinSurfaceTypeAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDADeviceBuiltinSurfaceTypeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CUDADeviceBuiltinTextureTypeAttr.h b/include/multiplier/AST/CUDADeviceBuiltinTextureTypeAttr.h
index 6eb0199a6..e576bc9c2 100644
--- a/include/multiplier/AST/CUDADeviceBuiltinTextureTypeAttr.h
+++ b/include/multiplier/AST/CUDADeviceBuiltinTextureTypeAttr.h
@@ -18,11 +18,6 @@ class CUDADeviceBuiltinTextureTypeAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDADeviceBuiltinTextureTypeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CUDAGlobalAttr.h b/include/multiplier/AST/CUDAGlobalAttr.h
index a8f461803..9fce09480 100644
--- a/include/multiplier/AST/CUDAGlobalAttr.h
+++ b/include/multiplier/AST/CUDAGlobalAttr.h
@@ -18,11 +18,6 @@ class CUDAGlobalAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDAGlobalAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CUDAHostAttr.h b/include/multiplier/AST/CUDAHostAttr.h
index d26805199..8cb920fcd 100644
--- a/include/multiplier/AST/CUDAHostAttr.h
+++ b/include/multiplier/AST/CUDAHostAttr.h
@@ -18,11 +18,6 @@ class CUDAHostAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDAHostAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CUDAInvalidTargetAttr.h b/include/multiplier/AST/CUDAInvalidTargetAttr.h
index a7b85bdf3..08db6b2bc 100644
--- a/include/multiplier/AST/CUDAInvalidTargetAttr.h
+++ b/include/multiplier/AST/CUDAInvalidTargetAttr.h
@@ -18,11 +18,6 @@ class CUDAInvalidTargetAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDAInvalidTargetAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CUDAKernelCallExpr.h b/include/multiplier/AST/CUDAKernelCallExpr.h
index 6c440da49..4a319a5f9 100644
--- a/include/multiplier/AST/CUDAKernelCallExpr.h
+++ b/include/multiplier/AST/CUDAKernelCallExpr.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDAKernelCallExpr : public CallExpr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT CUDAKernelCallExpr : public CallExpr {
   static gap::generator<CUDAKernelCallExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CUDAKernelCallExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CUDAKernelCallExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CUDAKernelCallExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CUDA_KERNEL_CALL_EXPR;
   }
diff --git a/include/multiplier/AST/CUDALaunchBoundsAttr.h b/include/multiplier/AST/CUDALaunchBoundsAttr.h
index b28176b56..563a17da5 100644
--- a/include/multiplier/AST/CUDALaunchBoundsAttr.h
+++ b/include/multiplier/AST/CUDALaunchBoundsAttr.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDALaunchBoundsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CUDASharedAttr.h b/include/multiplier/AST/CUDASharedAttr.h
index 35017a1ee..2c4585ad2 100644
--- a/include/multiplier/AST/CUDASharedAttr.h
+++ b/include/multiplier/AST/CUDASharedAttr.h
@@ -18,11 +18,6 @@ class CUDASharedAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CUDASharedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CXX11NoReturnAttr.h b/include/multiplier/AST/CXX11NoReturnAttr.h
index 001f3443c..08f19763e 100644
--- a/include/multiplier/AST/CXX11NoReturnAttr.h
+++ b/include/multiplier/AST/CXX11NoReturnAttr.h
@@ -19,11 +19,6 @@ class CXX11NoReturnAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXX11NoReturnAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CXXAddrspaceCastExpr.h b/include/multiplier/AST/CXXAddrspaceCastExpr.h
index f004261dd..44dc54313 100644
--- a/include/multiplier/AST/CXXAddrspaceCastExpr.h
+++ b/include/multiplier/AST/CXXAddrspaceCastExpr.h
@@ -23,11 +23,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXAddrspaceCastExpr : public CXXNamedCastExpr {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT CXXAddrspaceCastExpr : public CXXNamedCastExpr {
   static gap::generator<CXXAddrspaceCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXAddrspaceCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXAddrspaceCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXAddrspaceCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_ADDRSPACE_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/CXXBaseSpecifier.h b/include/multiplier/AST/CXXBaseSpecifier.h
index 5bb3c6de0..7a82ce2ae 100644
--- a/include/multiplier/AST/CXXBaseSpecifier.h
+++ b/include/multiplier/AST/CXXBaseSpecifier.h
@@ -37,11 +37,6 @@ class File;
 class Token;
 class TokenRange;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXBaseSpecifier {
  public:
@@ -60,8 +55,7 @@ class MX_EXPORT CXXBaseSpecifier {
   friend class TokenContext;
   friend class Type;
   friend class CXXBaseSpecifierImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const CXXBaseSpecifierImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
diff --git a/include/multiplier/AST/CXXBindTemporaryExpr.h b/include/multiplier/AST/CXXBindTemporaryExpr.h
index c06afdd46..e7ddfd017 100644
--- a/include/multiplier/AST/CXXBindTemporaryExpr.h
+++ b/include/multiplier/AST/CXXBindTemporaryExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXBindTemporaryExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT CXXBindTemporaryExpr : public Expr {
   static gap::generator<CXXBindTemporaryExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXBindTemporaryExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXBindTemporaryExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXBindTemporaryExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_BIND_TEMPORARY_EXPR;
   }
diff --git a/include/multiplier/AST/CXXBoolLiteralExpr.h b/include/multiplier/AST/CXXBoolLiteralExpr.h
index 7857c070b..fab3167a0 100644
--- a/include/multiplier/AST/CXXBoolLiteralExpr.h
+++ b/include/multiplier/AST/CXXBoolLiteralExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXBoolLiteralExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT CXXBoolLiteralExpr : public Expr {
   static gap::generator<CXXBoolLiteralExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXBoolLiteralExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXBoolLiteralExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXBoolLiteralExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_BOOL_LITERAL_EXPR;
   }
diff --git a/include/multiplier/AST/CXXCatchStmt.h b/include/multiplier/AST/CXXCatchStmt.h
index 1275803d2..0b29ef726 100644
--- a/include/multiplier/AST/CXXCatchStmt.h
+++ b/include/multiplier/AST/CXXCatchStmt.h
@@ -20,11 +20,6 @@ class Stmt;
 class Token;
 class Type;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXCatchStmt : public Stmt {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT CXXCatchStmt : public Stmt {
   static gap::generator<CXXCatchStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXCatchStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXCatchStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXCatchStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_CATCH_STMT;
   }
diff --git a/include/multiplier/AST/CXXConstCastExpr.h b/include/multiplier/AST/CXXConstCastExpr.h
index 901cf0c91..ea43855e2 100644
--- a/include/multiplier/AST/CXXConstCastExpr.h
+++ b/include/multiplier/AST/CXXConstCastExpr.h
@@ -23,11 +23,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXConstCastExpr : public CXXNamedCastExpr {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT CXXConstCastExpr : public CXXNamedCastExpr {
   static gap::generator<CXXConstCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXConstCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXConstCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXConstCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_CONST_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/CXXConstructExpr.h b/include/multiplier/AST/CXXConstructExpr.h
index 46acbf913..9958f54ff 100644
--- a/include/multiplier/AST/CXXConstructExpr.h
+++ b/include/multiplier/AST/CXXConstructExpr.h
@@ -23,11 +23,6 @@ class Stmt;
 class Token;
 class TokenRange;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXConstructExpr : public Expr {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT CXXConstructExpr : public Expr {
   static gap::generator<CXXConstructExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXConstructExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXConstructExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXConstructExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_CONSTRUCT_EXPR;
   }
diff --git a/include/multiplier/AST/CXXConstructorDecl.h b/include/multiplier/AST/CXXConstructorDecl.h
index b7a7ee2ee..9692951da 100644
--- a/include/multiplier/AST/CXXConstructorDecl.h
+++ b/include/multiplier/AST/CXXConstructorDecl.h
@@ -25,11 +25,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXConstructorDecl : public CXXMethodDecl {
  private:
@@ -47,8 +42,7 @@ class MX_EXPORT CXXConstructorDecl : public CXXMethodDecl {
   static gap::generator<CXXConstructorDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXConstructorDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXConstructorDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXConstructorDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CXX_CONSTRUCTOR;
   }
diff --git a/include/multiplier/AST/CXXConversionDecl.h b/include/multiplier/AST/CXXConversionDecl.h
index 9f91644db..d48072e80 100644
--- a/include/multiplier/AST/CXXConversionDecl.h
+++ b/include/multiplier/AST/CXXConversionDecl.h
@@ -25,11 +25,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXConversionDecl : public CXXMethodDecl {
  private:
@@ -47,8 +42,7 @@ class MX_EXPORT CXXConversionDecl : public CXXMethodDecl {
   static gap::generator<CXXConversionDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXConversionDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXConversionDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXConversionDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CXX_CONVERSION;
   }
diff --git a/include/multiplier/AST/CXXCtorInitializer.h b/include/multiplier/AST/CXXCtorInitializer.h
index 8deba0231..ff4105172 100644
--- a/include/multiplier/AST/CXXCtorInitializer.h
+++ b/include/multiplier/AST/CXXCtorInitializer.h
@@ -36,11 +36,6 @@ class IndirectFieldDecl;
 class Stmt;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXCtorInitializer {
  public:
@@ -58,8 +53,7 @@ class MX_EXPORT CXXCtorInitializer {
   friend class TokenContext;
   friend class Type;
   friend class CXXCtorInitializerImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const CXXCtorInitializerImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
diff --git a/include/multiplier/AST/CXXDeductionGuideDecl.h b/include/multiplier/AST/CXXDeductionGuideDecl.h
index c77bce511..58315d57f 100644
--- a/include/multiplier/AST/CXXDeductionGuideDecl.h
+++ b/include/multiplier/AST/CXXDeductionGuideDecl.h
@@ -26,11 +26,6 @@ class Stmt;
 class TemplateDecl;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXDeductionGuideDecl : public FunctionDecl {
  private:
@@ -47,8 +42,7 @@ class MX_EXPORT CXXDeductionGuideDecl : public FunctionDecl {
   static gap::generator<CXXDeductionGuideDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXDeductionGuideDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXDeductionGuideDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXDeductionGuideDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CXX_DEDUCTION_GUIDE;
   }
diff --git a/include/multiplier/AST/CXXDefaultArgExpr.h b/include/multiplier/AST/CXXDefaultArgExpr.h
index 48def5f7b..8f368c6dc 100644
--- a/include/multiplier/AST/CXXDefaultArgExpr.h
+++ b/include/multiplier/AST/CXXDefaultArgExpr.h
@@ -21,11 +21,6 @@ class ParmVarDecl;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXDefaultArgExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT CXXDefaultArgExpr : public Expr {
   static gap::generator<CXXDefaultArgExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXDefaultArgExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXDefaultArgExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXDefaultArgExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_DEFAULT_ARG_EXPR;
   }
diff --git a/include/multiplier/AST/CXXDefaultInitExpr.h b/include/multiplier/AST/CXXDefaultInitExpr.h
index ea9aff89e..f2f225290 100644
--- a/include/multiplier/AST/CXXDefaultInitExpr.h
+++ b/include/multiplier/AST/CXXDefaultInitExpr.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXDefaultInitExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT CXXDefaultInitExpr : public Expr {
   static gap::generator<CXXDefaultInitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXDefaultInitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXDefaultInitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXDefaultInitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_DEFAULT_INIT_EXPR;
   }
diff --git a/include/multiplier/AST/CXXDeleteExpr.h b/include/multiplier/AST/CXXDeleteExpr.h
index 31aba9f14..1e5ce0ebd 100644
--- a/include/multiplier/AST/CXXDeleteExpr.h
+++ b/include/multiplier/AST/CXXDeleteExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXDeleteExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT CXXDeleteExpr : public Expr {
   static gap::generator<CXXDeleteExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXDeleteExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXDeleteExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXDeleteExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_DELETE_EXPR;
   }
diff --git a/include/multiplier/AST/CXXDependentScopeMemberExpr.h b/include/multiplier/AST/CXXDependentScopeMemberExpr.h
index a30b52595..7a30d8435 100644
--- a/include/multiplier/AST/CXXDependentScopeMemberExpr.h
+++ b/include/multiplier/AST/CXXDependentScopeMemberExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXDependentScopeMemberExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT CXXDependentScopeMemberExpr : public Expr {
   static gap::generator<CXXDependentScopeMemberExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXDependentScopeMemberExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXDependentScopeMemberExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXDependentScopeMemberExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_DEPENDENT_SCOPE_MEMBER_EXPR;
   }
diff --git a/include/multiplier/AST/CXXDestructorDecl.h b/include/multiplier/AST/CXXDestructorDecl.h
index 1367ee622..01c656621 100644
--- a/include/multiplier/AST/CXXDestructorDecl.h
+++ b/include/multiplier/AST/CXXDestructorDecl.h
@@ -25,11 +25,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXDestructorDecl : public CXXMethodDecl {
  private:
@@ -47,8 +42,7 @@ class MX_EXPORT CXXDestructorDecl : public CXXMethodDecl {
   static gap::generator<CXXDestructorDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXDestructorDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXDestructorDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXDestructorDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CXX_DESTRUCTOR;
   }
diff --git a/include/multiplier/AST/CXXDynamicCastExpr.h b/include/multiplier/AST/CXXDynamicCastExpr.h
index 00e8fae5c..de7e2c520 100644
--- a/include/multiplier/AST/CXXDynamicCastExpr.h
+++ b/include/multiplier/AST/CXXDynamicCastExpr.h
@@ -23,11 +23,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXDynamicCastExpr : public CXXNamedCastExpr {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT CXXDynamicCastExpr : public CXXNamedCastExpr {
   static gap::generator<CXXDynamicCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXDynamicCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXDynamicCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXDynamicCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_DYNAMIC_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/CXXFoldExpr.h b/include/multiplier/AST/CXXFoldExpr.h
index dd3b3af11..d4a432532 100644
--- a/include/multiplier/AST/CXXFoldExpr.h
+++ b/include/multiplier/AST/CXXFoldExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class UnresolvedLookupExpr;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXFoldExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT CXXFoldExpr : public Expr {
   static gap::generator<CXXFoldExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXFoldExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXFoldExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXFoldExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_FOLD_EXPR;
   }
diff --git a/include/multiplier/AST/CXXForRangeStmt.h b/include/multiplier/AST/CXXForRangeStmt.h
index 6b980d6dd..f4ad49c6b 100644
--- a/include/multiplier/AST/CXXForRangeStmt.h
+++ b/include/multiplier/AST/CXXForRangeStmt.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXForRangeStmt : public Stmt {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT CXXForRangeStmt : public Stmt {
   static gap::generator<CXXForRangeStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXForRangeStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXForRangeStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXForRangeStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_FOR_RANGE_STMT;
   }
diff --git a/include/multiplier/AST/CXXFunctionalCastExpr.h b/include/multiplier/AST/CXXFunctionalCastExpr.h
index ae32a4577..e1090ac61 100644
--- a/include/multiplier/AST/CXXFunctionalCastExpr.h
+++ b/include/multiplier/AST/CXXFunctionalCastExpr.h
@@ -22,11 +22,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXFunctionalCastExpr : public ExplicitCastExpr {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT CXXFunctionalCastExpr : public ExplicitCastExpr {
   static gap::generator<CXXFunctionalCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXFunctionalCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXFunctionalCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXFunctionalCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_FUNCTIONAL_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/CXXInheritedCtorInitExpr.h b/include/multiplier/AST/CXXInheritedCtorInitExpr.h
index 9161fae2e..36d522409 100644
--- a/include/multiplier/AST/CXXInheritedCtorInitExpr.h
+++ b/include/multiplier/AST/CXXInheritedCtorInitExpr.h
@@ -22,11 +22,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXInheritedCtorInitExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT CXXInheritedCtorInitExpr : public Expr {
   static gap::generator<CXXInheritedCtorInitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXInheritedCtorInitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXInheritedCtorInitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXInheritedCtorInitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_INHERITED_CTOR_INIT_EXPR;
   }
diff --git a/include/multiplier/AST/CXXMemberCallExpr.h b/include/multiplier/AST/CXXMemberCallExpr.h
index c357f739a..afeada38a 100644
--- a/include/multiplier/AST/CXXMemberCallExpr.h
+++ b/include/multiplier/AST/CXXMemberCallExpr.h
@@ -24,11 +24,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXMemberCallExpr : public CallExpr {
  private:
@@ -44,8 +39,7 @@ class MX_EXPORT CXXMemberCallExpr : public CallExpr {
   static gap::generator<CXXMemberCallExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXMemberCallExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXMemberCallExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXMemberCallExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_MEMBER_CALL_EXPR;
   }
diff --git a/include/multiplier/AST/CXXMethodDecl.h b/include/multiplier/AST/CXXMethodDecl.h
index bb1175437..03d435726 100644
--- a/include/multiplier/AST/CXXMethodDecl.h
+++ b/include/multiplier/AST/CXXMethodDecl.h
@@ -25,11 +25,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXMethodDecl : public FunctionDecl {
  private:
@@ -46,8 +41,7 @@ class MX_EXPORT CXXMethodDecl : public FunctionDecl {
   static gap::generator<CXXMethodDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXMethodDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXMethodDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXMethodDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CXX_METHOD;
   }
diff --git a/include/multiplier/AST/CXXNamedCastExpr.h b/include/multiplier/AST/CXXNamedCastExpr.h
index f7cf00f3f..6a0d5ba24 100644
--- a/include/multiplier/AST/CXXNamedCastExpr.h
+++ b/include/multiplier/AST/CXXNamedCastExpr.h
@@ -23,11 +23,6 @@ class Stmt;
 class Token;
 class TokenRange;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXNamedCastExpr : public ExplicitCastExpr {
  private:
@@ -44,8 +39,7 @@ class MX_EXPORT CXXNamedCastExpr : public ExplicitCastExpr {
   static gap::generator<CXXNamedCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXNamedCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXNamedCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXNamedCastExpr> in(const Compilation &tu);
   static gap::generator<CXXNamedCastExpr> containing(const Decl &decl);
   static gap::generator<CXXNamedCastExpr> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/CXXNewExpr.h b/include/multiplier/AST/CXXNewExpr.h
index 42b786579..dfca56ee7 100644
--- a/include/multiplier/AST/CXXNewExpr.h
+++ b/include/multiplier/AST/CXXNewExpr.h
@@ -25,11 +25,6 @@ class Token;
 class TokenRange;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXNewExpr : public Expr {
  private:
@@ -44,8 +39,7 @@ class MX_EXPORT CXXNewExpr : public Expr {
   static gap::generator<CXXNewExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXNewExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXNewExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXNewExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_NEW_EXPR;
   }
diff --git a/include/multiplier/AST/CXXNoexceptExpr.h b/include/multiplier/AST/CXXNoexceptExpr.h
index 51e835456..03161dfb5 100644
--- a/include/multiplier/AST/CXXNoexceptExpr.h
+++ b/include/multiplier/AST/CXXNoexceptExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXNoexceptExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT CXXNoexceptExpr : public Expr {
   static gap::generator<CXXNoexceptExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXNoexceptExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXNoexceptExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXNoexceptExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_NOEXCEPT_EXPR;
   }
diff --git a/include/multiplier/AST/CXXNullPtrLiteralExpr.h b/include/multiplier/AST/CXXNullPtrLiteralExpr.h
index d989723a9..b322db5ff 100644
--- a/include/multiplier/AST/CXXNullPtrLiteralExpr.h
+++ b/include/multiplier/AST/CXXNullPtrLiteralExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXNullPtrLiteralExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT CXXNullPtrLiteralExpr : public Expr {
   static gap::generator<CXXNullPtrLiteralExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXNullPtrLiteralExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXNullPtrLiteralExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXNullPtrLiteralExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_NULL_PTR_LITERAL_EXPR;
   }
diff --git a/include/multiplier/AST/CXXOperatorCallExpr.h b/include/multiplier/AST/CXXOperatorCallExpr.h
index 8442ec608..aacf743c3 100644
--- a/include/multiplier/AST/CXXOperatorCallExpr.h
+++ b/include/multiplier/AST/CXXOperatorCallExpr.h
@@ -22,11 +22,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXOperatorCallExpr : public CallExpr {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT CXXOperatorCallExpr : public CallExpr {
   static gap::generator<CXXOperatorCallExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXOperatorCallExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXOperatorCallExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXOperatorCallExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_OPERATOR_CALL_EXPR;
   }
diff --git a/include/multiplier/AST/CXXParenListInitExpr.h b/include/multiplier/AST/CXXParenListInitExpr.h
index 8c78ebf8e..23ba5de63 100644
--- a/include/multiplier/AST/CXXParenListInitExpr.h
+++ b/include/multiplier/AST/CXXParenListInitExpr.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXParenListInitExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT CXXParenListInitExpr : public Expr {
   static gap::generator<CXXParenListInitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXParenListInitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXParenListInitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXParenListInitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_PAREN_LIST_INIT_EXPR;
   }
diff --git a/include/multiplier/AST/CXXPseudoDestructorExpr.h b/include/multiplier/AST/CXXPseudoDestructorExpr.h
index be7b0073f..9ef8f37e2 100644
--- a/include/multiplier/AST/CXXPseudoDestructorExpr.h
+++ b/include/multiplier/AST/CXXPseudoDestructorExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXPseudoDestructorExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT CXXPseudoDestructorExpr : public Expr {
   static gap::generator<CXXPseudoDestructorExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXPseudoDestructorExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXPseudoDestructorExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXPseudoDestructorExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_PSEUDO_DESTRUCTOR_EXPR;
   }
diff --git a/include/multiplier/AST/CXXRecordDecl.h b/include/multiplier/AST/CXXRecordDecl.h
index dceaa8247..29c039c1e 100644
--- a/include/multiplier/AST/CXXRecordDecl.h
+++ b/include/multiplier/AST/CXXRecordDecl.h
@@ -35,11 +35,6 @@ class TagDecl;
 class TemplateParameterList;
 class Token;
 class TypeDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXRecordDecl : public RecordDecl {
  private:
@@ -56,8 +51,7 @@ class MX_EXPORT CXXRecordDecl : public RecordDecl {
   static gap::generator<CXXRecordDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXRecordDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXRecordDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXRecordDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CXX_RECORD;
   }
diff --git a/include/multiplier/AST/CXXReinterpretCastExpr.h b/include/multiplier/AST/CXXReinterpretCastExpr.h
index 199bad79f..598c4bbd6 100644
--- a/include/multiplier/AST/CXXReinterpretCastExpr.h
+++ b/include/multiplier/AST/CXXReinterpretCastExpr.h
@@ -23,11 +23,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXReinterpretCastExpr : public CXXNamedCastExpr {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT CXXReinterpretCastExpr : public CXXNamedCastExpr {
   static gap::generator<CXXReinterpretCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXReinterpretCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXReinterpretCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXReinterpretCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_REINTERPRET_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/CXXRewrittenBinaryOperator.h b/include/multiplier/AST/CXXRewrittenBinaryOperator.h
index 250a760f2..a73234166 100644
--- a/include/multiplier/AST/CXXRewrittenBinaryOperator.h
+++ b/include/multiplier/AST/CXXRewrittenBinaryOperator.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXRewrittenBinaryOperator : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT CXXRewrittenBinaryOperator : public Expr {
   static gap::generator<CXXRewrittenBinaryOperator> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXRewrittenBinaryOperator> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXRewrittenBinaryOperator, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXRewrittenBinaryOperator> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_REWRITTEN_BINARY_OPERATOR;
   }
diff --git a/include/multiplier/AST/CXXScalarValueInitExpr.h b/include/multiplier/AST/CXXScalarValueInitExpr.h
index 3d97e4421..eaf8968c6 100644
--- a/include/multiplier/AST/CXXScalarValueInitExpr.h
+++ b/include/multiplier/AST/CXXScalarValueInitExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXScalarValueInitExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT CXXScalarValueInitExpr : public Expr {
   static gap::generator<CXXScalarValueInitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXScalarValueInitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXScalarValueInitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXScalarValueInitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_SCALAR_VALUE_INIT_EXPR;
   }
diff --git a/include/multiplier/AST/CXXStaticCastExpr.h b/include/multiplier/AST/CXXStaticCastExpr.h
index f65467614..b773b5b2c 100644
--- a/include/multiplier/AST/CXXStaticCastExpr.h
+++ b/include/multiplier/AST/CXXStaticCastExpr.h
@@ -23,11 +23,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXStaticCastExpr : public CXXNamedCastExpr {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT CXXStaticCastExpr : public CXXNamedCastExpr {
   static gap::generator<CXXStaticCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXStaticCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXStaticCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXStaticCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_STATIC_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/CXXStdInitializerListExpr.h b/include/multiplier/AST/CXXStdInitializerListExpr.h
index fd80dec99..848da3e2e 100644
--- a/include/multiplier/AST/CXXStdInitializerListExpr.h
+++ b/include/multiplier/AST/CXXStdInitializerListExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXStdInitializerListExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT CXXStdInitializerListExpr : public Expr {
   static gap::generator<CXXStdInitializerListExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXStdInitializerListExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXStdInitializerListExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXStdInitializerListExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_STD_INITIALIZER_LIST_EXPR;
   }
diff --git a/include/multiplier/AST/CXXTemporaryObjectExpr.h b/include/multiplier/AST/CXXTemporaryObjectExpr.h
index 3e0bcf2e7..509ae2605 100644
--- a/include/multiplier/AST/CXXTemporaryObjectExpr.h
+++ b/include/multiplier/AST/CXXTemporaryObjectExpr.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXTemporaryObjectExpr : public CXXConstructExpr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT CXXTemporaryObjectExpr : public CXXConstructExpr {
   static gap::generator<CXXTemporaryObjectExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXTemporaryObjectExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXTemporaryObjectExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXTemporaryObjectExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_TEMPORARY_OBJECT_EXPR;
   }
diff --git a/include/multiplier/AST/CXXThisExpr.h b/include/multiplier/AST/CXXThisExpr.h
index 4ba81f8a2..361d9397e 100644
--- a/include/multiplier/AST/CXXThisExpr.h
+++ b/include/multiplier/AST/CXXThisExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXThisExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT CXXThisExpr : public Expr {
   static gap::generator<CXXThisExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXThisExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXThisExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXThisExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_THIS_EXPR;
   }
diff --git a/include/multiplier/AST/CXXThrowExpr.h b/include/multiplier/AST/CXXThrowExpr.h
index e03ccc66d..8eb3dd0f8 100644
--- a/include/multiplier/AST/CXXThrowExpr.h
+++ b/include/multiplier/AST/CXXThrowExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXThrowExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT CXXThrowExpr : public Expr {
   static gap::generator<CXXThrowExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXThrowExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXThrowExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXThrowExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_THROW_EXPR;
   }
diff --git a/include/multiplier/AST/CXXTryStmt.h b/include/multiplier/AST/CXXTryStmt.h
index cc20d6e37..f0e482402 100644
--- a/include/multiplier/AST/CXXTryStmt.h
+++ b/include/multiplier/AST/CXXTryStmt.h
@@ -20,11 +20,6 @@ class Decl;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXTryStmt : public Stmt {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT CXXTryStmt : public Stmt {
   static gap::generator<CXXTryStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXTryStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXTryStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXTryStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_TRY_STMT;
   }
diff --git a/include/multiplier/AST/CXXTypeidExpr.h b/include/multiplier/AST/CXXTypeidExpr.h
index 6864c8e7c..8f0b08fe7 100644
--- a/include/multiplier/AST/CXXTypeidExpr.h
+++ b/include/multiplier/AST/CXXTypeidExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXTypeidExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT CXXTypeidExpr : public Expr {
   static gap::generator<CXXTypeidExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXTypeidExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXTypeidExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXTypeidExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_TYPEID_EXPR;
   }
diff --git a/include/multiplier/AST/CXXUnresolvedConstructExpr.h b/include/multiplier/AST/CXXUnresolvedConstructExpr.h
index 8815e3c44..4bea518a5 100644
--- a/include/multiplier/AST/CXXUnresolvedConstructExpr.h
+++ b/include/multiplier/AST/CXXUnresolvedConstructExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXUnresolvedConstructExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT CXXUnresolvedConstructExpr : public Expr {
   static gap::generator<CXXUnresolvedConstructExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXUnresolvedConstructExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXUnresolvedConstructExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXUnresolvedConstructExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_UNRESOLVED_CONSTRUCT_EXPR;
   }
diff --git a/include/multiplier/AST/CXXUuidofExpr.h b/include/multiplier/AST/CXXUuidofExpr.h
index c4c6a855d..a0e135590 100644
--- a/include/multiplier/AST/CXXUuidofExpr.h
+++ b/include/multiplier/AST/CXXUuidofExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CXXUuidofExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT CXXUuidofExpr : public Expr {
   static gap::generator<CXXUuidofExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CXXUuidofExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CXXUuidofExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CXXUuidofExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CXX_UUIDOF_EXPR;
   }
diff --git a/include/multiplier/AST/CallExpr.h b/include/multiplier/AST/CallExpr.h
index 59d8bd74d..1bd698fe3 100644
--- a/include/multiplier/AST/CallExpr.h
+++ b/include/multiplier/AST/CallExpr.h
@@ -24,11 +24,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CallExpr : public Expr {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT CallExpr : public Expr {
   static gap::generator<CallExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CallExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CallExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CallExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CALL_EXPR;
   }
diff --git a/include/multiplier/AST/CallableWhenAttr.h b/include/multiplier/AST/CallableWhenAttr.h
index aba185fbb..606ba13bd 100644
--- a/include/multiplier/AST/CallableWhenAttr.h
+++ b/include/multiplier/AST/CallableWhenAttr.h
@@ -18,11 +18,6 @@ class CallableWhenAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CallableWhenAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CallbackAttr.h b/include/multiplier/AST/CallbackAttr.h
index 838d5070e..5ed7678fa 100644
--- a/include/multiplier/AST/CallbackAttr.h
+++ b/include/multiplier/AST/CallbackAttr.h
@@ -18,11 +18,6 @@ class CallbackAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CallbackAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CalledOnceAttr.h b/include/multiplier/AST/CalledOnceAttr.h
index 268d3c27a..b83dfb8e1 100644
--- a/include/multiplier/AST/CalledOnceAttr.h
+++ b/include/multiplier/AST/CalledOnceAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class CalledOnceAttr;
 class File;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CalledOnceAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/CapabilityAttr.h b/include/multiplier/AST/CapabilityAttr.h
index 094099214..9662b7d35 100644
--- a/include/multiplier/AST/CapabilityAttr.h
+++ b/include/multiplier/AST/CapabilityAttr.h
@@ -19,11 +19,6 @@ class CapabilityAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CapabilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CapturedDecl.h b/include/multiplier/AST/CapturedDecl.h
index b09ef5e6a..9f7fc13ca 100644
--- a/include/multiplier/AST/CapturedDecl.h
+++ b/include/multiplier/AST/CapturedDecl.h
@@ -20,11 +20,6 @@ class File;
 class ImplicitParamDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CapturedDecl : public Decl {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT CapturedDecl : public Decl {
   static gap::generator<CapturedDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CapturedDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<CapturedDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CapturedDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CAPTURED;
   }
diff --git a/include/multiplier/AST/CapturedRecordAttr.h b/include/multiplier/AST/CapturedRecordAttr.h
index b82d132eb..47c7c41eb 100644
--- a/include/multiplier/AST/CapturedRecordAttr.h
+++ b/include/multiplier/AST/CapturedRecordAttr.h
@@ -18,11 +18,6 @@ class CapturedRecordAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CapturedRecordAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CapturedStmt.h b/include/multiplier/AST/CapturedStmt.h
index 24f4bbc3d..3865c7f89 100644
--- a/include/multiplier/AST/CapturedStmt.h
+++ b/include/multiplier/AST/CapturedStmt.h
@@ -21,11 +21,6 @@ class File;
 class RecordDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CapturedStmt : public Stmt {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT CapturedStmt : public Stmt {
   static gap::generator<CapturedStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CapturedStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<CapturedStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CapturedStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CAPTURED_STMT;
   }
diff --git a/include/multiplier/AST/CarriesDependencyAttr.h b/include/multiplier/AST/CarriesDependencyAttr.h
index 88d3d21c3..207a32ac7 100644
--- a/include/multiplier/AST/CarriesDependencyAttr.h
+++ b/include/multiplier/AST/CarriesDependencyAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class InheritableParamAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CarriesDependencyAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/CaseStmt.h b/include/multiplier/AST/CaseStmt.h
index 604360f7a..c1a849ae0 100644
--- a/include/multiplier/AST/CaseStmt.h
+++ b/include/multiplier/AST/CaseStmt.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class SwitchCase;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CaseStmt : public SwitchCase {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT CaseStmt : public SwitchCase {
   static gap::generator<CaseStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CaseStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<CaseStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CaseStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CASE_STMT;
   }
diff --git a/include/multiplier/AST/CastExpr.h b/include/multiplier/AST/CastExpr.h
index b8995b976..ab3b16421 100644
--- a/include/multiplier/AST/CastExpr.h
+++ b/include/multiplier/AST/CastExpr.h
@@ -23,11 +23,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CastExpr : public Expr {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT CastExpr : public Expr {
   static gap::generator<CastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CastExpr> in(const Compilation &tu);
   static gap::generator<CastExpr> containing(const Decl &decl);
   static gap::generator<CastExpr> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/CharacterLiteral.h b/include/multiplier/AST/CharacterLiteral.h
index 651b14ab1..2419b4fb0 100644
--- a/include/multiplier/AST/CharacterLiteral.h
+++ b/include/multiplier/AST/CharacterLiteral.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CharacterLiteral : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT CharacterLiteral : public Expr {
   static gap::generator<CharacterLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CharacterLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<CharacterLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CharacterLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CHARACTER_LITERAL;
   }
diff --git a/include/multiplier/AST/ChooseExpr.h b/include/multiplier/AST/ChooseExpr.h
index 487725bd8..b34c48a65 100644
--- a/include/multiplier/AST/ChooseExpr.h
+++ b/include/multiplier/AST/ChooseExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ChooseExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ChooseExpr : public Expr {
   static gap::generator<ChooseExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ChooseExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ChooseExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ChooseExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CHOOSE_EXPR;
   }
diff --git a/include/multiplier/AST/ClassTemplateDecl.h b/include/multiplier/AST/ClassTemplateDecl.h
index 5dbf2b789..3f4f4da0a 100644
--- a/include/multiplier/AST/ClassTemplateDecl.h
+++ b/include/multiplier/AST/ClassTemplateDecl.h
@@ -21,11 +21,6 @@ class RedeclarableTemplateDecl;
 class Stmt;
 class TemplateDecl;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ClassTemplateDecl : public RedeclarableTemplateDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT ClassTemplateDecl : public RedeclarableTemplateDecl {
   static gap::generator<ClassTemplateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ClassTemplateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ClassTemplateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ClassTemplateDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CLASS_TEMPLATE;
   }
diff --git a/include/multiplier/AST/ClassTemplatePartialSpecializationDecl.h b/include/multiplier/AST/ClassTemplatePartialSpecializationDecl.h
index f9412bafa..df91d2d21 100644
--- a/include/multiplier/AST/ClassTemplatePartialSpecializationDecl.h
+++ b/include/multiplier/AST/ClassTemplatePartialSpecializationDecl.h
@@ -27,11 +27,6 @@ class TemplateParameterList;
 class Token;
 class Type;
 class TypeDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ClassTemplatePartialSpecializationDecl : public ClassTemplateSpecializationDecl {
  private:
@@ -50,8 +45,7 @@ class MX_EXPORT ClassTemplatePartialSpecializationDecl : public ClassTemplateSpe
   static gap::generator<ClassTemplatePartialSpecializationDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ClassTemplatePartialSpecializationDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ClassTemplatePartialSpecializationDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ClassTemplatePartialSpecializationDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
   }
diff --git a/include/multiplier/AST/ClassTemplateSpecializationDecl.h b/include/multiplier/AST/ClassTemplateSpecializationDecl.h
index 9ba1eb808..411f0f093 100644
--- a/include/multiplier/AST/ClassTemplateSpecializationDecl.h
+++ b/include/multiplier/AST/ClassTemplateSpecializationDecl.h
@@ -27,11 +27,6 @@ class TagDecl;
 class TemplateArgument;
 class Token;
 class TypeDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ClassTemplateSpecializationDecl : public CXXRecordDecl {
  private:
@@ -49,8 +44,7 @@ class MX_EXPORT ClassTemplateSpecializationDecl : public CXXRecordDecl {
   static gap::generator<ClassTemplateSpecializationDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ClassTemplateSpecializationDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ClassTemplateSpecializationDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ClassTemplateSpecializationDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CLASS_TEMPLATE_SPECIALIZATION;
   }
diff --git a/include/multiplier/AST/CleanupAttr.h b/include/multiplier/AST/CleanupAttr.h
index ef4f1765d..28a012b69 100644
--- a/include/multiplier/AST/CleanupAttr.h
+++ b/include/multiplier/AST/CleanupAttr.h
@@ -19,11 +19,6 @@ class File;
 class FunctionDecl;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CleanupAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CmseNSCallAttr.h b/include/multiplier/AST/CmseNSCallAttr.h
index 9afa373e6..8eba6655b 100644
--- a/include/multiplier/AST/CmseNSCallAttr.h
+++ b/include/multiplier/AST/CmseNSCallAttr.h
@@ -18,11 +18,6 @@ class CmseNSCallAttr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CmseNSCallAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/CmseNSEntryAttr.h b/include/multiplier/AST/CmseNSEntryAttr.h
index fb801e6ac..f0d74a81e 100644
--- a/include/multiplier/AST/CmseNSEntryAttr.h
+++ b/include/multiplier/AST/CmseNSEntryAttr.h
@@ -18,11 +18,6 @@ class CmseNSEntryAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CmseNSEntryAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CoawaitExpr.h b/include/multiplier/AST/CoawaitExpr.h
index b3ef3500e..993a62174 100644
--- a/include/multiplier/AST/CoawaitExpr.h
+++ b/include/multiplier/AST/CoawaitExpr.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoawaitExpr : public CoroutineSuspendExpr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT CoawaitExpr : public CoroutineSuspendExpr {
   static gap::generator<CoawaitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CoawaitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CoawaitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CoawaitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::COAWAIT_EXPR;
   }
diff --git a/include/multiplier/AST/CodeAlignAttr.h b/include/multiplier/AST/CodeAlignAttr.h
index 7b9d7b19f..f09284ba5 100644
--- a/include/multiplier/AST/CodeAlignAttr.h
+++ b/include/multiplier/AST/CodeAlignAttr.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class StmtAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CodeAlignAttr : public StmtAttr {
  private:
diff --git a/include/multiplier/AST/CodeModelAttr.h b/include/multiplier/AST/CodeModelAttr.h
index 9f6243532..ae215a99f 100644
--- a/include/multiplier/AST/CodeModelAttr.h
+++ b/include/multiplier/AST/CodeModelAttr.h
@@ -18,11 +18,6 @@ class CodeModelAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CodeModelAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CodeSegAttr.h b/include/multiplier/AST/CodeSegAttr.h
index 925846b85..a46c56903 100644
--- a/include/multiplier/AST/CodeSegAttr.h
+++ b/include/multiplier/AST/CodeSegAttr.h
@@ -18,11 +18,6 @@ class CodeSegAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CodeSegAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ColdAttr.h b/include/multiplier/AST/ColdAttr.h
index 13c2695c9..db166d6b2 100644
--- a/include/multiplier/AST/ColdAttr.h
+++ b/include/multiplier/AST/ColdAttr.h
@@ -18,11 +18,6 @@ class ColdAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ColdAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CommonAttr.h b/include/multiplier/AST/CommonAttr.h
index f7fb68160..edd953671 100644
--- a/include/multiplier/AST/CommonAttr.h
+++ b/include/multiplier/AST/CommonAttr.h
@@ -18,11 +18,6 @@ class CommonAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CommonAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ComplexType.h b/include/multiplier/AST/ComplexType.h
index de6526d24..c0b1d908d 100644
--- a/include/multiplier/AST/ComplexType.h
+++ b/include/multiplier/AST/ComplexType.h
@@ -16,11 +16,6 @@ class Index;
 class ComplexType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ComplexType : public Type {
  private:
diff --git a/include/multiplier/AST/CompoundAssignOperator.h b/include/multiplier/AST/CompoundAssignOperator.h
index c940f4adc..19a7d5b5e 100644
--- a/include/multiplier/AST/CompoundAssignOperator.h
+++ b/include/multiplier/AST/CompoundAssignOperator.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CompoundAssignOperator : public BinaryOperator {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT CompoundAssignOperator : public BinaryOperator {
   static gap::generator<CompoundAssignOperator> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CompoundAssignOperator> from(const ir::Operation &op);
-  static gap::generator<std::pair<CompoundAssignOperator, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CompoundAssignOperator> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::COMPOUND_ASSIGN_OPERATOR;
   }
diff --git a/include/multiplier/AST/CompoundLiteralExpr.h b/include/multiplier/AST/CompoundLiteralExpr.h
index c511d8394..8e11f12c3 100644
--- a/include/multiplier/AST/CompoundLiteralExpr.h
+++ b/include/multiplier/AST/CompoundLiteralExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CompoundLiteralExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT CompoundLiteralExpr : public Expr {
   static gap::generator<CompoundLiteralExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CompoundLiteralExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CompoundLiteralExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CompoundLiteralExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::COMPOUND_LITERAL_EXPR;
   }
diff --git a/include/multiplier/AST/CompoundStmt.h b/include/multiplier/AST/CompoundStmt.h
index 4d54f28aa..03002b501 100644
--- a/include/multiplier/AST/CompoundStmt.h
+++ b/include/multiplier/AST/CompoundStmt.h
@@ -18,11 +18,6 @@ class Decl;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CompoundStmt : public Stmt {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT CompoundStmt : public Stmt {
   static gap::generator<CompoundStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CompoundStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<CompoundStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CompoundStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::COMPOUND_STMT;
   }
diff --git a/include/multiplier/AST/ConceptDecl.h b/include/multiplier/AST/ConceptDecl.h
index a3e48a7cb..fc4da0690 100644
--- a/include/multiplier/AST/ConceptDecl.h
+++ b/include/multiplier/AST/ConceptDecl.h
@@ -21,11 +21,6 @@ class NamedDecl;
 class Stmt;
 class TemplateDecl;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConceptDecl : public TemplateDecl {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ConceptDecl : public TemplateDecl {
   static gap::generator<ConceptDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ConceptDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ConceptDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ConceptDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CONCEPT;
   }
diff --git a/include/multiplier/AST/ConceptSpecializationExpr.h b/include/multiplier/AST/ConceptSpecializationExpr.h
index b2a6b060c..ab760f226 100644
--- a/include/multiplier/AST/ConceptSpecializationExpr.h
+++ b/include/multiplier/AST/ConceptSpecializationExpr.h
@@ -24,11 +24,6 @@ class Stmt;
 class TemplateArgument;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConceptSpecializationExpr : public Expr {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT ConceptSpecializationExpr : public Expr {
   static gap::generator<ConceptSpecializationExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ConceptSpecializationExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ConceptSpecializationExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ConceptSpecializationExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CONCEPT_SPECIALIZATION_EXPR;
   }
diff --git a/include/multiplier/AST/ConditionalOperator.h b/include/multiplier/AST/ConditionalOperator.h
index e142b8375..e5fbb6181 100644
--- a/include/multiplier/AST/ConditionalOperator.h
+++ b/include/multiplier/AST/ConditionalOperator.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConditionalOperator : public AbstractConditionalOperator {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT ConditionalOperator : public AbstractConditionalOperator {
   static gap::generator<ConditionalOperator> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ConditionalOperator> from(const ir::Operation &op);
-  static gap::generator<std::pair<ConditionalOperator, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ConditionalOperator> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CONDITIONAL_OPERATOR;
   }
diff --git a/include/multiplier/AST/ConstAttr.h b/include/multiplier/AST/ConstAttr.h
index d8f4ff8c1..0214743a5 100644
--- a/include/multiplier/AST/ConstAttr.h
+++ b/include/multiplier/AST/ConstAttr.h
@@ -18,11 +18,6 @@ class ConstAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConstAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ConstInitAttr.h b/include/multiplier/AST/ConstInitAttr.h
index 2c88fa789..2c72abc20 100644
--- a/include/multiplier/AST/ConstInitAttr.h
+++ b/include/multiplier/AST/ConstInitAttr.h
@@ -19,11 +19,6 @@ class ConstInitAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConstInitAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ConstantArrayType.h b/include/multiplier/AST/ConstantArrayType.h
index df1eac55b..2c1e212b1 100644
--- a/include/multiplier/AST/ConstantArrayType.h
+++ b/include/multiplier/AST/ConstantArrayType.h
@@ -18,11 +18,6 @@ class ConstantArrayType;
 class Expr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConstantArrayType : public ArrayType {
  private:
diff --git a/include/multiplier/AST/ConstantExpr.h b/include/multiplier/AST/ConstantExpr.h
index c01665c06..0fea008ec 100644
--- a/include/multiplier/AST/ConstantExpr.h
+++ b/include/multiplier/AST/ConstantExpr.h
@@ -22,11 +22,6 @@ class FullExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConstantExpr : public FullExpr {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT ConstantExpr : public FullExpr {
   static gap::generator<ConstantExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ConstantExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ConstantExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ConstantExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CONSTANT_EXPR;
   }
diff --git a/include/multiplier/AST/ConstantMatrixType.h b/include/multiplier/AST/ConstantMatrixType.h
index 31759cf3b..03c851f95 100644
--- a/include/multiplier/AST/ConstantMatrixType.h
+++ b/include/multiplier/AST/ConstantMatrixType.h
@@ -17,11 +17,6 @@ class ConstantMatrixType;
 class MatrixType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConstantMatrixType : public MatrixType {
  private:
diff --git a/include/multiplier/AST/ConstructorAttr.h b/include/multiplier/AST/ConstructorAttr.h
index 6e59ccfd6..6f5dd60a3 100644
--- a/include/multiplier/AST/ConstructorAttr.h
+++ b/include/multiplier/AST/ConstructorAttr.h
@@ -18,11 +18,6 @@ class ConstructorAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConstructorAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ConstructorUsingShadowDecl.h b/include/multiplier/AST/ConstructorUsingShadowDecl.h
index 61a026b38..c558f3756 100644
--- a/include/multiplier/AST/ConstructorUsingShadowDecl.h
+++ b/include/multiplier/AST/ConstructorUsingShadowDecl.h
@@ -21,11 +21,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class UsingShadowDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConstructorUsingShadowDecl : public UsingShadowDecl {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ConstructorUsingShadowDecl : public UsingShadowDecl {
   static gap::generator<ConstructorUsingShadowDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ConstructorUsingShadowDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ConstructorUsingShadowDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ConstructorUsingShadowDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::CONSTRUCTOR_USING_SHADOW;
   }
diff --git a/include/multiplier/AST/ConsumableAttr.h b/include/multiplier/AST/ConsumableAttr.h
index f8dd3407b..8a4d7fbeb 100644
--- a/include/multiplier/AST/ConsumableAttr.h
+++ b/include/multiplier/AST/ConsumableAttr.h
@@ -19,11 +19,6 @@ class ConsumableAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConsumableAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ConsumableAutoCastAttr.h b/include/multiplier/AST/ConsumableAutoCastAttr.h
index 571e90569..d57e083f3 100644
--- a/include/multiplier/AST/ConsumableAutoCastAttr.h
+++ b/include/multiplier/AST/ConsumableAutoCastAttr.h
@@ -18,11 +18,6 @@ class ConsumableAutoCastAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConsumableAutoCastAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ConsumableSetOnReadAttr.h b/include/multiplier/AST/ConsumableSetOnReadAttr.h
index a2b443b9e..8ba48e498 100644
--- a/include/multiplier/AST/ConsumableSetOnReadAttr.h
+++ b/include/multiplier/AST/ConsumableSetOnReadAttr.h
@@ -18,11 +18,6 @@ class ConsumableSetOnReadAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConsumableSetOnReadAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ContinueStmt.h b/include/multiplier/AST/ContinueStmt.h
index 7bab6862c..29e23f140 100644
--- a/include/multiplier/AST/ContinueStmt.h
+++ b/include/multiplier/AST/ContinueStmt.h
@@ -18,11 +18,6 @@ class Decl;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ContinueStmt : public Stmt {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT ContinueStmt : public Stmt {
   static gap::generator<ContinueStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ContinueStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ContinueStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ContinueStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CONTINUE_STMT;
   }
diff --git a/include/multiplier/AST/ConvergentAttr.h b/include/multiplier/AST/ConvergentAttr.h
index c09e997d0..51d1461d3 100644
--- a/include/multiplier/AST/ConvergentAttr.h
+++ b/include/multiplier/AST/ConvergentAttr.h
@@ -18,11 +18,6 @@ class ConvergentAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConvergentAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ConvertVectorExpr.h b/include/multiplier/AST/ConvertVectorExpr.h
index 9bfe1b0ff..138769006 100644
--- a/include/multiplier/AST/ConvertVectorExpr.h
+++ b/include/multiplier/AST/ConvertVectorExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConvertVectorExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ConvertVectorExpr : public Expr {
   static gap::generator<ConvertVectorExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ConvertVectorExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ConvertVectorExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ConvertVectorExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CONVERT_VECTOR_EXPR;
   }
diff --git a/include/multiplier/AST/CoreturnStmt.h b/include/multiplier/AST/CoreturnStmt.h
index 995371241..6438f3679 100644
--- a/include/multiplier/AST/CoreturnStmt.h
+++ b/include/multiplier/AST/CoreturnStmt.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoreturnStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT CoreturnStmt : public Stmt {
   static gap::generator<CoreturnStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CoreturnStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<CoreturnStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CoreturnStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::CORETURN_STMT;
   }
diff --git a/include/multiplier/AST/CoroDisableLifetimeBoundAttr.h b/include/multiplier/AST/CoroDisableLifetimeBoundAttr.h
index e6b8e39ec..8bd6d9c10 100644
--- a/include/multiplier/AST/CoroDisableLifetimeBoundAttr.h
+++ b/include/multiplier/AST/CoroDisableLifetimeBoundAttr.h
@@ -18,11 +18,6 @@ class CoroDisableLifetimeBoundAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoroDisableLifetimeBoundAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CoroLifetimeBoundAttr.h b/include/multiplier/AST/CoroLifetimeBoundAttr.h
index 6cc3e2ff8..b7cdd3b7f 100644
--- a/include/multiplier/AST/CoroLifetimeBoundAttr.h
+++ b/include/multiplier/AST/CoroLifetimeBoundAttr.h
@@ -18,11 +18,6 @@ class CoroLifetimeBoundAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoroLifetimeBoundAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CoroOnlyDestroyWhenCompleteAttr.h b/include/multiplier/AST/CoroOnlyDestroyWhenCompleteAttr.h
index 7db1d8f09..7b3b4be1f 100644
--- a/include/multiplier/AST/CoroOnlyDestroyWhenCompleteAttr.h
+++ b/include/multiplier/AST/CoroOnlyDestroyWhenCompleteAttr.h
@@ -18,11 +18,6 @@ class CoroOnlyDestroyWhenCompleteAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoroOnlyDestroyWhenCompleteAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CoroReturnTypeAttr.h b/include/multiplier/AST/CoroReturnTypeAttr.h
index 7d12a89d1..f7894a010 100644
--- a/include/multiplier/AST/CoroReturnTypeAttr.h
+++ b/include/multiplier/AST/CoroReturnTypeAttr.h
@@ -18,11 +18,6 @@ class CoroReturnTypeAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoroReturnTypeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CoroWrapperAttr.h b/include/multiplier/AST/CoroWrapperAttr.h
index 509e09e37..39efb9ed6 100644
--- a/include/multiplier/AST/CoroWrapperAttr.h
+++ b/include/multiplier/AST/CoroWrapperAttr.h
@@ -18,11 +18,6 @@ class CoroWrapperAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoroWrapperAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CoroutineBodyStmt.h b/include/multiplier/AST/CoroutineBodyStmt.h
index e13c10f57..aab969671 100644
--- a/include/multiplier/AST/CoroutineBodyStmt.h
+++ b/include/multiplier/AST/CoroutineBodyStmt.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoroutineBodyStmt : public Stmt {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT CoroutineBodyStmt : public Stmt {
   static gap::generator<CoroutineBodyStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CoroutineBodyStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<CoroutineBodyStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CoroutineBodyStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::COROUTINE_BODY_STMT;
   }
diff --git a/include/multiplier/AST/CoroutineSuspendExpr.h b/include/multiplier/AST/CoroutineSuspendExpr.h
index be414ba32..f27b481c9 100644
--- a/include/multiplier/AST/CoroutineSuspendExpr.h
+++ b/include/multiplier/AST/CoroutineSuspendExpr.h
@@ -21,11 +21,6 @@ class OpaqueValueExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoroutineSuspendExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT CoroutineSuspendExpr : public Expr {
   static gap::generator<CoroutineSuspendExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CoroutineSuspendExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CoroutineSuspendExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CoroutineSuspendExpr> in(const Compilation &tu);
   static gap::generator<CoroutineSuspendExpr> containing(const Decl &decl);
   static gap::generator<CoroutineSuspendExpr> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/CountedByAttr.h b/include/multiplier/AST/CountedByAttr.h
index 5ee9cfb9a..84a551976 100644
--- a/include/multiplier/AST/CountedByAttr.h
+++ b/include/multiplier/AST/CountedByAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CountedByAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/CoyieldExpr.h b/include/multiplier/AST/CoyieldExpr.h
index 2f8c296f7..73f584bed 100644
--- a/include/multiplier/AST/CoyieldExpr.h
+++ b/include/multiplier/AST/CoyieldExpr.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT CoyieldExpr : public CoroutineSuspendExpr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT CoyieldExpr : public CoroutineSuspendExpr {
   static gap::generator<CoyieldExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<CoyieldExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<CoyieldExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<CoyieldExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::COYIELD_EXPR;
   }
diff --git a/include/multiplier/AST/DLLExportAttr.h b/include/multiplier/AST/DLLExportAttr.h
index 583d45945..1e9cc7f4f 100644
--- a/include/multiplier/AST/DLLExportAttr.h
+++ b/include/multiplier/AST/DLLExportAttr.h
@@ -18,11 +18,6 @@ class DLLExportAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DLLExportAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DLLExportStaticLocalAttr.h b/include/multiplier/AST/DLLExportStaticLocalAttr.h
index 9504be41f..a2b69ee90 100644
--- a/include/multiplier/AST/DLLExportStaticLocalAttr.h
+++ b/include/multiplier/AST/DLLExportStaticLocalAttr.h
@@ -18,11 +18,6 @@ class DLLExportStaticLocalAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DLLExportStaticLocalAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DLLImportAttr.h b/include/multiplier/AST/DLLImportAttr.h
index 4178d31d8..21ccf674e 100644
--- a/include/multiplier/AST/DLLImportAttr.h
+++ b/include/multiplier/AST/DLLImportAttr.h
@@ -18,11 +18,6 @@ class DLLImportAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DLLImportAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DLLImportStaticLocalAttr.h b/include/multiplier/AST/DLLImportStaticLocalAttr.h
index de6d60c45..c9e624d75 100644
--- a/include/multiplier/AST/DLLImportStaticLocalAttr.h
+++ b/include/multiplier/AST/DLLImportStaticLocalAttr.h
@@ -18,11 +18,6 @@ class DLLImportStaticLocalAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DLLImportStaticLocalAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DecayedType.h b/include/multiplier/AST/DecayedType.h
index 5a05fa52b..4ecf8df1d 100644
--- a/include/multiplier/AST/DecayedType.h
+++ b/include/multiplier/AST/DecayedType.h
@@ -17,11 +17,6 @@ class AdjustedType;
 class DecayedType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DecayedType : public AdjustedType {
  private:
diff --git a/include/multiplier/AST/Decl.h b/include/multiplier/AST/Decl.h
index 1d846d7b3..f32eded64 100644
--- a/include/multiplier/AST/Decl.h
+++ b/include/multiplier/AST/Decl.h
@@ -40,11 +40,6 @@ class File;
 class Stmt;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT Decl {
  public:
@@ -62,8 +57,7 @@ class MX_EXPORT Decl {
   friend class TokenContext;
   friend class Type;
   friend class DeclImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const DeclImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
@@ -103,9 +97,8 @@ class MX_EXPORT Decl {
   static gap::generator<Decl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<Decl> from(const ir::Operation &op);
-  static gap::generator<std::pair<Decl, ir::Operation>> in(const Compilation &tu);
-  static gap::generator<std::pair<Decl, ir::Operation>> in(const Compilation &tu, std::span<const DeclKind> kinds);
+  static gap::generator<Decl> in(const Compilation &tu);
+  static gap::generator<Decl> in(const Compilation &tu, std::span<const DeclKind> kinds);
 
   static gap::generator<Decl> containing(const Decl &decl);
   static gap::generator<Decl> containing(const std::optional<Decl> &decl);
diff --git a/include/multiplier/AST/DeclOrStmtAttr.h b/include/multiplier/AST/DeclOrStmtAttr.h
index 814772423..050345392 100644
--- a/include/multiplier/AST/DeclOrStmtAttr.h
+++ b/include/multiplier/AST/DeclOrStmtAttr.h
@@ -18,11 +18,6 @@ class DeclOrStmtAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DeclOrStmtAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DeclRefExpr.h b/include/multiplier/AST/DeclRefExpr.h
index c69adaf74..a0856e7d2 100644
--- a/include/multiplier/AST/DeclRefExpr.h
+++ b/include/multiplier/AST/DeclRefExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class ValueDecl;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DeclRefExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT DeclRefExpr : public Expr {
   static gap::generator<DeclRefExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DeclRefExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<DeclRefExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DeclRefExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::DECL_REF_EXPR;
   }
diff --git a/include/multiplier/AST/DeclStmt.h b/include/multiplier/AST/DeclStmt.h
index 31ab59073..3ab5522fa 100644
--- a/include/multiplier/AST/DeclStmt.h
+++ b/include/multiplier/AST/DeclStmt.h
@@ -18,11 +18,6 @@ class DeclStmt;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DeclStmt : public Stmt {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT DeclStmt : public Stmt {
   static gap::generator<DeclStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DeclStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<DeclStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DeclStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::DECL_STMT;
   }
diff --git a/include/multiplier/AST/DeclaratorDecl.h b/include/multiplier/AST/DeclaratorDecl.h
index ee737efc1..5f4beb8ac 100644
--- a/include/multiplier/AST/DeclaratorDecl.h
+++ b/include/multiplier/AST/DeclaratorDecl.h
@@ -22,11 +22,6 @@ class Stmt;
 class TemplateParameterList;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DeclaratorDecl : public ValueDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT DeclaratorDecl : public ValueDecl {
   static gap::generator<DeclaratorDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DeclaratorDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<DeclaratorDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DeclaratorDecl> in(const Compilation &tu);
   static gap::generator<DeclaratorDecl> containing(const Decl &decl);
   static gap::generator<DeclaratorDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/DecltypeType.h b/include/multiplier/AST/DecltypeType.h
index b666a9ca9..239178bb2 100644
--- a/include/multiplier/AST/DecltypeType.h
+++ b/include/multiplier/AST/DecltypeType.h
@@ -17,11 +17,6 @@ class DecltypeType;
 class Expr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DecltypeType : public Type {
  private:
diff --git a/include/multiplier/AST/DecompositionDecl.h b/include/multiplier/AST/DecompositionDecl.h
index f24447e4a..ef51faf24 100644
--- a/include/multiplier/AST/DecompositionDecl.h
+++ b/include/multiplier/AST/DecompositionDecl.h
@@ -23,11 +23,6 @@ class Stmt;
 class Token;
 class ValueDecl;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DecompositionDecl : public VarDecl {
  private:
@@ -44,8 +39,7 @@ class MX_EXPORT DecompositionDecl : public VarDecl {
   static gap::generator<DecompositionDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DecompositionDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<DecompositionDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DecompositionDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::DECOMPOSITION;
   }
diff --git a/include/multiplier/AST/DeducedTemplateSpecializationType.h b/include/multiplier/AST/DeducedTemplateSpecializationType.h
index a8132d597..852e47c6e 100644
--- a/include/multiplier/AST/DeducedTemplateSpecializationType.h
+++ b/include/multiplier/AST/DeducedTemplateSpecializationType.h
@@ -17,11 +17,6 @@ class DeducedTemplateSpecializationType;
 class DeducedType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DeducedTemplateSpecializationType : public DeducedType {
  private:
diff --git a/include/multiplier/AST/DeducedType.h b/include/multiplier/AST/DeducedType.h
index 8561cd95a..d413b33dd 100644
--- a/include/multiplier/AST/DeducedType.h
+++ b/include/multiplier/AST/DeducedType.h
@@ -16,11 +16,6 @@ class Index;
 class DeducedType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DeducedType : public Type {
  private:
diff --git a/include/multiplier/AST/DefaultStmt.h b/include/multiplier/AST/DefaultStmt.h
index 6b2adeabb..c4d4dbf7f 100644
--- a/include/multiplier/AST/DefaultStmt.h
+++ b/include/multiplier/AST/DefaultStmt.h
@@ -19,11 +19,6 @@ class File;
 class Stmt;
 class SwitchCase;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DefaultStmt : public SwitchCase {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT DefaultStmt : public SwitchCase {
   static gap::generator<DefaultStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DefaultStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<DefaultStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DefaultStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::DEFAULT_STMT;
   }
diff --git a/include/multiplier/AST/DependentAddressSpaceType.h b/include/multiplier/AST/DependentAddressSpaceType.h
index d42d0816d..184d2c70f 100644
--- a/include/multiplier/AST/DependentAddressSpaceType.h
+++ b/include/multiplier/AST/DependentAddressSpaceType.h
@@ -17,11 +17,6 @@ class DependentAddressSpaceType;
 class Expr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentAddressSpaceType : public Type {
  private:
diff --git a/include/multiplier/AST/DependentBitIntType.h b/include/multiplier/AST/DependentBitIntType.h
index 1b1e3f7e4..c199183f0 100644
--- a/include/multiplier/AST/DependentBitIntType.h
+++ b/include/multiplier/AST/DependentBitIntType.h
@@ -17,11 +17,6 @@ class DependentBitIntType;
 class Expr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentBitIntType : public Type {
  private:
diff --git a/include/multiplier/AST/DependentCoawaitExpr.h b/include/multiplier/AST/DependentCoawaitExpr.h
index 60dd2a7b2..ed8cbc146 100644
--- a/include/multiplier/AST/DependentCoawaitExpr.h
+++ b/include/multiplier/AST/DependentCoawaitExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class UnresolvedLookupExpr;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentCoawaitExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT DependentCoawaitExpr : public Expr {
   static gap::generator<DependentCoawaitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DependentCoawaitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<DependentCoawaitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DependentCoawaitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::DEPENDENT_COAWAIT_EXPR;
   }
diff --git a/include/multiplier/AST/DependentNameType.h b/include/multiplier/AST/DependentNameType.h
index 1d6d4da68..cec155f7d 100644
--- a/include/multiplier/AST/DependentNameType.h
+++ b/include/multiplier/AST/DependentNameType.h
@@ -17,11 +17,6 @@ class DependentNameType;
 class Token;
 class Type;
 class TypeWithKeyword;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentNameType : public TypeWithKeyword {
  private:
diff --git a/include/multiplier/AST/DependentScopeDeclRefExpr.h b/include/multiplier/AST/DependentScopeDeclRefExpr.h
index 581ccf87f..5f3d5d702 100644
--- a/include/multiplier/AST/DependentScopeDeclRefExpr.h
+++ b/include/multiplier/AST/DependentScopeDeclRefExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentScopeDeclRefExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT DependentScopeDeclRefExpr : public Expr {
   static gap::generator<DependentScopeDeclRefExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DependentScopeDeclRefExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<DependentScopeDeclRefExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DependentScopeDeclRefExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::DEPENDENT_SCOPE_DECL_REF_EXPR;
   }
diff --git a/include/multiplier/AST/DependentSizedArrayType.h b/include/multiplier/AST/DependentSizedArrayType.h
index ebe43214d..c2951a138 100644
--- a/include/multiplier/AST/DependentSizedArrayType.h
+++ b/include/multiplier/AST/DependentSizedArrayType.h
@@ -19,11 +19,6 @@ class Expr;
 class Token;
 class TokenRange;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentSizedArrayType : public ArrayType {
  private:
diff --git a/include/multiplier/AST/DependentSizedExtVectorType.h b/include/multiplier/AST/DependentSizedExtVectorType.h
index 596251092..0f24ae500 100644
--- a/include/multiplier/AST/DependentSizedExtVectorType.h
+++ b/include/multiplier/AST/DependentSizedExtVectorType.h
@@ -17,11 +17,6 @@ class DependentSizedExtVectorType;
 class Expr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentSizedExtVectorType : public Type {
  private:
diff --git a/include/multiplier/AST/DependentSizedMatrixType.h b/include/multiplier/AST/DependentSizedMatrixType.h
index ef88e91c9..f4e9dd77e 100644
--- a/include/multiplier/AST/DependentSizedMatrixType.h
+++ b/include/multiplier/AST/DependentSizedMatrixType.h
@@ -18,11 +18,6 @@ class Expr;
 class MatrixType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentSizedMatrixType : public MatrixType {
  private:
diff --git a/include/multiplier/AST/DependentTemplateSpecializationType.h b/include/multiplier/AST/DependentTemplateSpecializationType.h
index ea2512d42..5895b7322 100644
--- a/include/multiplier/AST/DependentTemplateSpecializationType.h
+++ b/include/multiplier/AST/DependentTemplateSpecializationType.h
@@ -18,11 +18,6 @@ class TemplateArgument;
 class Token;
 class Type;
 class TypeWithKeyword;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentTemplateSpecializationType : public TypeWithKeyword {
  private:
diff --git a/include/multiplier/AST/DependentVectorType.h b/include/multiplier/AST/DependentVectorType.h
index e04227a5f..fc551188b 100644
--- a/include/multiplier/AST/DependentVectorType.h
+++ b/include/multiplier/AST/DependentVectorType.h
@@ -18,11 +18,6 @@ class DependentVectorType;
 class Expr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DependentVectorType : public Type {
  private:
diff --git a/include/multiplier/AST/DeprecatedAttr.h b/include/multiplier/AST/DeprecatedAttr.h
index 8d9de1708..58b268128 100644
--- a/include/multiplier/AST/DeprecatedAttr.h
+++ b/include/multiplier/AST/DeprecatedAttr.h
@@ -18,11 +18,6 @@ class DeprecatedAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DeprecatedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DesignatedInitExpr.h b/include/multiplier/AST/DesignatedInitExpr.h
index c346e7780..93f3c9b26 100644
--- a/include/multiplier/AST/DesignatedInitExpr.h
+++ b/include/multiplier/AST/DesignatedInitExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class TokenRange;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DesignatedInitExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT DesignatedInitExpr : public Expr {
   static gap::generator<DesignatedInitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DesignatedInitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<DesignatedInitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DesignatedInitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::DESIGNATED_INIT_EXPR;
   }
diff --git a/include/multiplier/AST/DesignatedInitUpdateExpr.h b/include/multiplier/AST/DesignatedInitUpdateExpr.h
index 3e3a7ff3d..963c953ea 100644
--- a/include/multiplier/AST/DesignatedInitUpdateExpr.h
+++ b/include/multiplier/AST/DesignatedInitUpdateExpr.h
@@ -21,11 +21,6 @@ class InitListExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DesignatedInitUpdateExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT DesignatedInitUpdateExpr : public Expr {
   static gap::generator<DesignatedInitUpdateExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DesignatedInitUpdateExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<DesignatedInitUpdateExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DesignatedInitUpdateExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::DESIGNATED_INIT_UPDATE_EXPR;
   }
diff --git a/include/multiplier/AST/Designator.h b/include/multiplier/AST/Designator.h
index 4204991c4..00374ef66 100644
--- a/include/multiplier/AST/Designator.h
+++ b/include/multiplier/AST/Designator.h
@@ -34,11 +34,6 @@ class FieldDecl;
 class File;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT Designator {
  public:
@@ -57,8 +52,7 @@ class MX_EXPORT Designator {
   friend class TokenContext;
   friend class Type;
   friend class DesignatorImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const DesignatorImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
diff --git a/include/multiplier/AST/DestructorAttr.h b/include/multiplier/AST/DestructorAttr.h
index 31a39542c..61a59891a 100644
--- a/include/multiplier/AST/DestructorAttr.h
+++ b/include/multiplier/AST/DestructorAttr.h
@@ -18,11 +18,6 @@ class DestructorAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DestructorAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DiagnoseAsBuiltinAttr.h b/include/multiplier/AST/DiagnoseAsBuiltinAttr.h
index b53133806..38853fb06 100644
--- a/include/multiplier/AST/DiagnoseAsBuiltinAttr.h
+++ b/include/multiplier/AST/DiagnoseAsBuiltinAttr.h
@@ -19,11 +19,6 @@ class File;
 class FunctionDecl;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DiagnoseAsBuiltinAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DiagnoseIfAttr.h b/include/multiplier/AST/DiagnoseIfAttr.h
index 06e836dd7..edfb3ae4a 100644
--- a/include/multiplier/AST/DiagnoseIfAttr.h
+++ b/include/multiplier/AST/DiagnoseIfAttr.h
@@ -21,11 +21,6 @@ class File;
 class InheritableAttr;
 class NamedDecl;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DiagnoseIfAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DisableSanitizerInstrumentationAttr.h b/include/multiplier/AST/DisableSanitizerInstrumentationAttr.h
index 1181c350d..ae3d5120a 100644
--- a/include/multiplier/AST/DisableSanitizerInstrumentationAttr.h
+++ b/include/multiplier/AST/DisableSanitizerInstrumentationAttr.h
@@ -18,11 +18,6 @@ class DisableSanitizerInstrumentationAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DisableSanitizerInstrumentationAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DisableTailCallsAttr.h b/include/multiplier/AST/DisableTailCallsAttr.h
index e17c06580..3e05baf80 100644
--- a/include/multiplier/AST/DisableTailCallsAttr.h
+++ b/include/multiplier/AST/DisableTailCallsAttr.h
@@ -18,11 +18,6 @@ class DisableTailCallsAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DisableTailCallsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/DoStmt.h b/include/multiplier/AST/DoStmt.h
index 1c1d97fb5..7e0be36b0 100644
--- a/include/multiplier/AST/DoStmt.h
+++ b/include/multiplier/AST/DoStmt.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DoStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT DoStmt : public Stmt {
   static gap::generator<DoStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<DoStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<DoStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<DoStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::DO_STMT;
   }
diff --git a/include/multiplier/AST/ElaboratedType.h b/include/multiplier/AST/ElaboratedType.h
index 0679b94b6..4299ec563 100644
--- a/include/multiplier/AST/ElaboratedType.h
+++ b/include/multiplier/AST/ElaboratedType.h
@@ -18,11 +18,6 @@ class TagDecl;
 class Token;
 class Type;
 class TypeWithKeyword;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ElaboratedType : public TypeWithKeyword {
  private:
diff --git a/include/multiplier/AST/EmptyBasesAttr.h b/include/multiplier/AST/EmptyBasesAttr.h
index 4d11fd9d7..05c9da087 100644
--- a/include/multiplier/AST/EmptyBasesAttr.h
+++ b/include/multiplier/AST/EmptyBasesAttr.h
@@ -18,11 +18,6 @@ class EmptyBasesAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EmptyBasesAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/EmptyDecl.h b/include/multiplier/AST/EmptyDecl.h
index f9da95f5e..7e8619e9d 100644
--- a/include/multiplier/AST/EmptyDecl.h
+++ b/include/multiplier/AST/EmptyDecl.h
@@ -18,11 +18,6 @@ class EmptyDecl;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EmptyDecl : public Decl {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT EmptyDecl : public Decl {
   static gap::generator<EmptyDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<EmptyDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<EmptyDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<EmptyDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::EMPTY;
   }
diff --git a/include/multiplier/AST/EnableIfAttr.h b/include/multiplier/AST/EnableIfAttr.h
index bea04b97f..0e2280a4b 100644
--- a/include/multiplier/AST/EnableIfAttr.h
+++ b/include/multiplier/AST/EnableIfAttr.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EnableIfAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/EnforceTCBAttr.h b/include/multiplier/AST/EnforceTCBAttr.h
index 8a5bde501..398828f40 100644
--- a/include/multiplier/AST/EnforceTCBAttr.h
+++ b/include/multiplier/AST/EnforceTCBAttr.h
@@ -18,11 +18,6 @@ class EnforceTCBAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EnforceTCBAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/EnforceTCBLeafAttr.h b/include/multiplier/AST/EnforceTCBLeafAttr.h
index 53bd4c51f..8beef7010 100644
--- a/include/multiplier/AST/EnforceTCBLeafAttr.h
+++ b/include/multiplier/AST/EnforceTCBLeafAttr.h
@@ -18,11 +18,6 @@ class EnforceTCBLeafAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EnforceTCBLeafAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/EnumConstantDecl.h b/include/multiplier/AST/EnumConstantDecl.h
index 5b69ece3a..a8ba03f3b 100644
--- a/include/multiplier/AST/EnumConstantDecl.h
+++ b/include/multiplier/AST/EnumConstantDecl.h
@@ -21,11 +21,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EnumConstantDecl : public ValueDecl {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT EnumConstantDecl : public ValueDecl {
   static gap::generator<EnumConstantDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<EnumConstantDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<EnumConstantDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<EnumConstantDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::ENUM_CONSTANT;
   }
diff --git a/include/multiplier/AST/EnumDecl.h b/include/multiplier/AST/EnumDecl.h
index ff8d6104a..73772543a 100644
--- a/include/multiplier/AST/EnumDecl.h
+++ b/include/multiplier/AST/EnumDecl.h
@@ -25,11 +25,6 @@ class Token;
 class TokenRange;
 class Type;
 class TypeDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EnumDecl : public TagDecl {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT EnumDecl : public TagDecl {
   static gap::generator<EnumDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<EnumDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<EnumDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<EnumDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::ENUM;
   }
diff --git a/include/multiplier/AST/EnumExtensibilityAttr.h b/include/multiplier/AST/EnumExtensibilityAttr.h
index 51731a589..cbed92d9b 100644
--- a/include/multiplier/AST/EnumExtensibilityAttr.h
+++ b/include/multiplier/AST/EnumExtensibilityAttr.h
@@ -19,11 +19,6 @@ class EnumExtensibilityAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EnumExtensibilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/EnumType.h b/include/multiplier/AST/EnumType.h
index 37221305d..b2a074e64 100644
--- a/include/multiplier/AST/EnumType.h
+++ b/include/multiplier/AST/EnumType.h
@@ -17,11 +17,6 @@ class EnumType;
 class TagType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EnumType : public TagType {
  private:
diff --git a/include/multiplier/AST/ErrorAttr.h b/include/multiplier/AST/ErrorAttr.h
index 2bdb2a426..47095a8bc 100644
--- a/include/multiplier/AST/ErrorAttr.h
+++ b/include/multiplier/AST/ErrorAttr.h
@@ -19,11 +19,6 @@ class ErrorAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ErrorAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ExcludeFromExplicitInstantiationAttr.h b/include/multiplier/AST/ExcludeFromExplicitInstantiationAttr.h
index 377def5de..bf9592a55 100644
--- a/include/multiplier/AST/ExcludeFromExplicitInstantiationAttr.h
+++ b/include/multiplier/AST/ExcludeFromExplicitInstantiationAttr.h
@@ -18,11 +18,6 @@ class ExcludeFromExplicitInstantiationAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExcludeFromExplicitInstantiationAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ExclusiveTrylockFunctionAttr.h b/include/multiplier/AST/ExclusiveTrylockFunctionAttr.h
index 3187503b6..fc35f5c50 100644
--- a/include/multiplier/AST/ExclusiveTrylockFunctionAttr.h
+++ b/include/multiplier/AST/ExclusiveTrylockFunctionAttr.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExclusiveTrylockFunctionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ExplicitCastExpr.h b/include/multiplier/AST/ExplicitCastExpr.h
index f66d06562..d9c40b02c 100644
--- a/include/multiplier/AST/ExplicitCastExpr.h
+++ b/include/multiplier/AST/ExplicitCastExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExplicitCastExpr : public CastExpr {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT ExplicitCastExpr : public CastExpr {
   static gap::generator<ExplicitCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ExplicitCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ExplicitCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ExplicitCastExpr> in(const Compilation &tu);
   static gap::generator<ExplicitCastExpr> containing(const Decl &decl);
   static gap::generator<ExplicitCastExpr> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/ExportDecl.h b/include/multiplier/AST/ExportDecl.h
index 71a84f7cc..36d5e6de4 100644
--- a/include/multiplier/AST/ExportDecl.h
+++ b/include/multiplier/AST/ExportDecl.h
@@ -19,11 +19,6 @@ class ExportDecl;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExportDecl : public Decl {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT ExportDecl : public Decl {
   static gap::generator<ExportDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ExportDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ExportDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ExportDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::EXPORT;
   }
diff --git a/include/multiplier/AST/Expr.h b/include/multiplier/AST/Expr.h
index bcef20ff9..827b9cf7a 100644
--- a/include/multiplier/AST/Expr.h
+++ b/include/multiplier/AST/Expr.h
@@ -24,11 +24,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT Expr : public ValueStmt {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT Expr : public ValueStmt {
   static gap::generator<Expr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<Expr> from(const ir::Operation &op);
-  static gap::generator<std::pair<Expr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<Expr> in(const Compilation &tu);
   static gap::generator<Expr> containing(const Decl &decl);
   static gap::generator<Expr> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/ExprWithCleanups.h b/include/multiplier/AST/ExprWithCleanups.h
index ae9dd8949..2252b9f14 100644
--- a/include/multiplier/AST/ExprWithCleanups.h
+++ b/include/multiplier/AST/ExprWithCleanups.h
@@ -21,11 +21,6 @@ class FullExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExprWithCleanups : public FullExpr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT ExprWithCleanups : public FullExpr {
   static gap::generator<ExprWithCleanups> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ExprWithCleanups> from(const ir::Operation &op);
-  static gap::generator<std::pair<ExprWithCleanups, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ExprWithCleanups> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::EXPR_WITH_CLEANUPS;
   }
diff --git a/include/multiplier/AST/ExpressionTraitExpr.h b/include/multiplier/AST/ExpressionTraitExpr.h
index 23c0a19ab..5eaa85ca6 100644
--- a/include/multiplier/AST/ExpressionTraitExpr.h
+++ b/include/multiplier/AST/ExpressionTraitExpr.h
@@ -21,11 +21,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExpressionTraitExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ExpressionTraitExpr : public Expr {
   static gap::generator<ExpressionTraitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ExpressionTraitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ExpressionTraitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ExpressionTraitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::EXPRESSION_TRAIT_EXPR;
   }
diff --git a/include/multiplier/AST/ExtVectorElementExpr.h b/include/multiplier/AST/ExtVectorElementExpr.h
index 807cd2fff..67d4a5ce2 100644
--- a/include/multiplier/AST/ExtVectorElementExpr.h
+++ b/include/multiplier/AST/ExtVectorElementExpr.h
@@ -20,11 +20,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExtVectorElementExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ExtVectorElementExpr : public Expr {
   static gap::generator<ExtVectorElementExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ExtVectorElementExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ExtVectorElementExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ExtVectorElementExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::EXT_VECTOR_ELEMENT_EXPR;
   }
diff --git a/include/multiplier/AST/ExtVectorType.h b/include/multiplier/AST/ExtVectorType.h
index c32e6cf8d..5923b5ff7 100644
--- a/include/multiplier/AST/ExtVectorType.h
+++ b/include/multiplier/AST/ExtVectorType.h
@@ -17,11 +17,6 @@ class ExtVectorType;
 class Token;
 class Type;
 class VectorType;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExtVectorType : public VectorType {
  private:
diff --git a/include/multiplier/AST/ExternCContextDecl.h b/include/multiplier/AST/ExternCContextDecl.h
index 2c2a04765..bb09aa0b9 100644
--- a/include/multiplier/AST/ExternCContextDecl.h
+++ b/include/multiplier/AST/ExternCContextDecl.h
@@ -19,11 +19,6 @@ class ExternCContextDecl;
 class File;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExternCContextDecl : public Decl {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT ExternCContextDecl : public Decl {
   static gap::generator<ExternCContextDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ExternCContextDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ExternCContextDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ExternCContextDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::EXTERN_C_CONTEXT;
   }
diff --git a/include/multiplier/AST/ExternalSourceSymbolAttr.h b/include/multiplier/AST/ExternalSourceSymbolAttr.h
index b48d3ed6a..c939d04c0 100644
--- a/include/multiplier/AST/ExternalSourceSymbolAttr.h
+++ b/include/multiplier/AST/ExternalSourceSymbolAttr.h
@@ -18,11 +18,6 @@ class ExternalSourceSymbolAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ExternalSourceSymbolAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/FallThroughAttr.h b/include/multiplier/AST/FallThroughAttr.h
index 23a327660..e0f7b4e52 100644
--- a/include/multiplier/AST/FallThroughAttr.h
+++ b/include/multiplier/AST/FallThroughAttr.h
@@ -18,11 +18,6 @@ class FallThroughAttr;
 class File;
 class StmtAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FallThroughAttr : public StmtAttr {
  private:
diff --git a/include/multiplier/AST/FastCallAttr.h b/include/multiplier/AST/FastCallAttr.h
index bd566ad9c..eb8859adf 100644
--- a/include/multiplier/AST/FastCallAttr.h
+++ b/include/multiplier/AST/FastCallAttr.h
@@ -18,11 +18,6 @@ class FastCallAttr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FastCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/FieldDecl.h b/include/multiplier/AST/FieldDecl.h
index b24784ac8..b88c4816d 100644
--- a/include/multiplier/AST/FieldDecl.h
+++ b/include/multiplier/AST/FieldDecl.h
@@ -24,11 +24,6 @@ class Stmt;
 class Token;
 class ValueDecl;
 class VariableArrayType;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FieldDecl : public DeclaratorDecl {
  private:
@@ -44,8 +39,7 @@ class MX_EXPORT FieldDecl : public DeclaratorDecl {
   static gap::generator<FieldDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FieldDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<FieldDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FieldDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::FIELD;
   }
diff --git a/include/multiplier/AST/FileScopeAsmDecl.h b/include/multiplier/AST/FileScopeAsmDecl.h
index 592b84d7b..6690a3da7 100644
--- a/include/multiplier/AST/FileScopeAsmDecl.h
+++ b/include/multiplier/AST/FileScopeAsmDecl.h
@@ -19,11 +19,6 @@ class FileScopeAsmDecl;
 class Stmt;
 class StringLiteral;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FileScopeAsmDecl : public Decl {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT FileScopeAsmDecl : public Decl {
   static gap::generator<FileScopeAsmDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FileScopeAsmDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<FileScopeAsmDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FileScopeAsmDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::FILE_SCOPE_ASM;
   }
diff --git a/include/multiplier/AST/FinalAttr.h b/include/multiplier/AST/FinalAttr.h
index 31c3051ce..6db43e310 100644
--- a/include/multiplier/AST/FinalAttr.h
+++ b/include/multiplier/AST/FinalAttr.h
@@ -19,11 +19,6 @@ class File;
 class FinalAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FinalAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/FixedPointLiteral.h b/include/multiplier/AST/FixedPointLiteral.h
index 5214fae23..7f30aa2c0 100644
--- a/include/multiplier/AST/FixedPointLiteral.h
+++ b/include/multiplier/AST/FixedPointLiteral.h
@@ -20,11 +20,6 @@ class FixedPointLiteral;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FixedPointLiteral : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT FixedPointLiteral : public Expr {
   static gap::generator<FixedPointLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FixedPointLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<FixedPointLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FixedPointLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::FIXED_POINT_LITERAL;
   }
diff --git a/include/multiplier/AST/FlagEnumAttr.h b/include/multiplier/AST/FlagEnumAttr.h
index d75db42cd..58c6d5eea 100644
--- a/include/multiplier/AST/FlagEnumAttr.h
+++ b/include/multiplier/AST/FlagEnumAttr.h
@@ -18,11 +18,6 @@ class File;
 class FlagEnumAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FlagEnumAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/FlattenAttr.h b/include/multiplier/AST/FlattenAttr.h
index db42122eb..a35ab2187 100644
--- a/include/multiplier/AST/FlattenAttr.h
+++ b/include/multiplier/AST/FlattenAttr.h
@@ -18,11 +18,6 @@ class File;
 class FlattenAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FlattenAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/FloatingLiteral.h b/include/multiplier/AST/FloatingLiteral.h
index e1bea3b91..878473492 100644
--- a/include/multiplier/AST/FloatingLiteral.h
+++ b/include/multiplier/AST/FloatingLiteral.h
@@ -20,11 +20,6 @@ class FloatingLiteral;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FloatingLiteral : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT FloatingLiteral : public Expr {
   static gap::generator<FloatingLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FloatingLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<FloatingLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FloatingLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::FLOATING_LITERAL;
   }
diff --git a/include/multiplier/AST/ForStmt.h b/include/multiplier/AST/ForStmt.h
index 82de17850..1b103fc98 100644
--- a/include/multiplier/AST/ForStmt.h
+++ b/include/multiplier/AST/ForStmt.h
@@ -21,11 +21,6 @@ class ForStmt;
 class Stmt;
 class Token;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ForStmt : public Stmt {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT ForStmt : public Stmt {
   static gap::generator<ForStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ForStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ForStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ForStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::FOR_STMT;
   }
diff --git a/include/multiplier/AST/FormatArgAttr.h b/include/multiplier/AST/FormatArgAttr.h
index 1a60a538e..2357594fa 100644
--- a/include/multiplier/AST/FormatArgAttr.h
+++ b/include/multiplier/AST/FormatArgAttr.h
@@ -18,11 +18,6 @@ class File;
 class FormatArgAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FormatArgAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/FormatAttr.h b/include/multiplier/AST/FormatAttr.h
index 803a789bc..87e8615e1 100644
--- a/include/multiplier/AST/FormatAttr.h
+++ b/include/multiplier/AST/FormatAttr.h
@@ -18,11 +18,6 @@ class File;
 class FormatAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FormatAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/FriendDecl.h b/include/multiplier/AST/FriendDecl.h
index afa25fcaf..694135e01 100644
--- a/include/multiplier/AST/FriendDecl.h
+++ b/include/multiplier/AST/FriendDecl.h
@@ -21,11 +21,6 @@ class Stmt;
 class TemplateParameterList;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FriendDecl : public Decl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT FriendDecl : public Decl {
   static gap::generator<FriendDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FriendDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<FriendDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FriendDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::FRIEND;
   }
diff --git a/include/multiplier/AST/FriendTemplateDecl.h b/include/multiplier/AST/FriendTemplateDecl.h
index 4f0013278..09253bde2 100644
--- a/include/multiplier/AST/FriendTemplateDecl.h
+++ b/include/multiplier/AST/FriendTemplateDecl.h
@@ -21,11 +21,6 @@ class Stmt;
 class TemplateParameterList;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FriendTemplateDecl : public Decl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT FriendTemplateDecl : public Decl {
   static gap::generator<FriendTemplateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FriendTemplateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<FriendTemplateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FriendTemplateDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::FRIEND_TEMPLATE;
   }
diff --git a/include/multiplier/AST/FullExpr.h b/include/multiplier/AST/FullExpr.h
index ee9585b39..72b9ca887 100644
--- a/include/multiplier/AST/FullExpr.h
+++ b/include/multiplier/AST/FullExpr.h
@@ -20,11 +20,6 @@ class FullExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FullExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT FullExpr : public Expr {
   static gap::generator<FullExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FullExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<FullExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FullExpr> in(const Compilation &tu);
   static gap::generator<FullExpr> containing(const Decl &decl);
   static gap::generator<FullExpr> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/FunctionDecl.h b/include/multiplier/AST/FunctionDecl.h
index 0e5cb222e..b5afd1a48 100644
--- a/include/multiplier/AST/FunctionDecl.h
+++ b/include/multiplier/AST/FunctionDecl.h
@@ -34,11 +34,6 @@ class Token;
 class TokenRange;
 class Type;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FunctionDecl : public DeclaratorDecl {
  private:
@@ -54,8 +49,7 @@ class MX_EXPORT FunctionDecl : public DeclaratorDecl {
   static gap::generator<FunctionDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FunctionDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<FunctionDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FunctionDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::FUNCTION;
   }
diff --git a/include/multiplier/AST/FunctionNoProtoType.h b/include/multiplier/AST/FunctionNoProtoType.h
index 8c35e4b55..766b7b3a1 100644
--- a/include/multiplier/AST/FunctionNoProtoType.h
+++ b/include/multiplier/AST/FunctionNoProtoType.h
@@ -17,11 +17,6 @@ class FunctionNoProtoType;
 class FunctionType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FunctionNoProtoType : public FunctionType {
  private:
diff --git a/include/multiplier/AST/FunctionParmPackExpr.h b/include/multiplier/AST/FunctionParmPackExpr.h
index 5b345f55b..a7e3ca293 100644
--- a/include/multiplier/AST/FunctionParmPackExpr.h
+++ b/include/multiplier/AST/FunctionParmPackExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class ValueStmt;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FunctionParmPackExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT FunctionParmPackExpr : public Expr {
   static gap::generator<FunctionParmPackExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FunctionParmPackExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<FunctionParmPackExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FunctionParmPackExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::FUNCTION_PARM_PACK_EXPR;
   }
diff --git a/include/multiplier/AST/FunctionProtoType.h b/include/multiplier/AST/FunctionProtoType.h
index d5ab087aa..a89048cd5 100644
--- a/include/multiplier/AST/FunctionProtoType.h
+++ b/include/multiplier/AST/FunctionProtoType.h
@@ -22,11 +22,6 @@ class FunctionProtoType;
 class FunctionType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FunctionProtoType : public FunctionType {
  private:
diff --git a/include/multiplier/AST/FunctionReturnThunksAttr.h b/include/multiplier/AST/FunctionReturnThunksAttr.h
index a0f42f6ff..4a31bfb6a 100644
--- a/include/multiplier/AST/FunctionReturnThunksAttr.h
+++ b/include/multiplier/AST/FunctionReturnThunksAttr.h
@@ -19,11 +19,6 @@ class File;
 class FunctionReturnThunksAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FunctionReturnThunksAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/FunctionTemplateDecl.h b/include/multiplier/AST/FunctionTemplateDecl.h
index a8d913856..b51357d5d 100644
--- a/include/multiplier/AST/FunctionTemplateDecl.h
+++ b/include/multiplier/AST/FunctionTemplateDecl.h
@@ -21,11 +21,6 @@ class RedeclarableTemplateDecl;
 class Stmt;
 class TemplateDecl;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FunctionTemplateDecl : public RedeclarableTemplateDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT FunctionTemplateDecl : public RedeclarableTemplateDecl {
   static gap::generator<FunctionTemplateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<FunctionTemplateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<FunctionTemplateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<FunctionTemplateDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::FUNCTION_TEMPLATE;
   }
diff --git a/include/multiplier/AST/FunctionType.h b/include/multiplier/AST/FunctionType.h
index 960f9d6b0..c691cedc4 100644
--- a/include/multiplier/AST/FunctionType.h
+++ b/include/multiplier/AST/FunctionType.h
@@ -17,11 +17,6 @@ class Index;
 class FunctionType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT FunctionType : public Type {
  private:
diff --git a/include/multiplier/AST/GCCAsmStmt.h b/include/multiplier/AST/GCCAsmStmt.h
index e539bf968..5b12aa95f 100644
--- a/include/multiplier/AST/GCCAsmStmt.h
+++ b/include/multiplier/AST/GCCAsmStmt.h
@@ -21,11 +21,6 @@ class GCCAsmStmt;
 class Stmt;
 class StringLiteral;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT GCCAsmStmt : public AsmStmt {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT GCCAsmStmt : public AsmStmt {
   static gap::generator<GCCAsmStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<GCCAsmStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<GCCAsmStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<GCCAsmStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::GCC_ASM_STMT;
   }
diff --git a/include/multiplier/AST/GNUInlineAttr.h b/include/multiplier/AST/GNUInlineAttr.h
index 112b47bea..a4741c705 100644
--- a/include/multiplier/AST/GNUInlineAttr.h
+++ b/include/multiplier/AST/GNUInlineAttr.h
@@ -18,11 +18,6 @@ class File;
 class GNUInlineAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT GNUInlineAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/GNUNullExpr.h b/include/multiplier/AST/GNUNullExpr.h
index 3d7c48c8b..3f6d7ad17 100644
--- a/include/multiplier/AST/GNUNullExpr.h
+++ b/include/multiplier/AST/GNUNullExpr.h
@@ -20,11 +20,6 @@ class GNUNullExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT GNUNullExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT GNUNullExpr : public Expr {
   static gap::generator<GNUNullExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<GNUNullExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<GNUNullExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<GNUNullExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::GNU_NULL_EXPR;
   }
diff --git a/include/multiplier/AST/GenericSelectionExpr.h b/include/multiplier/AST/GenericSelectionExpr.h
index 8b49c2931..f94eb9997 100644
--- a/include/multiplier/AST/GenericSelectionExpr.h
+++ b/include/multiplier/AST/GenericSelectionExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT GenericSelectionExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT GenericSelectionExpr : public Expr {
   static gap::generator<GenericSelectionExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<GenericSelectionExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<GenericSelectionExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<GenericSelectionExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::GENERIC_SELECTION_EXPR;
   }
diff --git a/include/multiplier/AST/GotoStmt.h b/include/multiplier/AST/GotoStmt.h
index 8a3dfca94..26f955081 100644
--- a/include/multiplier/AST/GotoStmt.h
+++ b/include/multiplier/AST/GotoStmt.h
@@ -19,11 +19,6 @@ class GotoStmt;
 class LabelDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT GotoStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT GotoStmt : public Stmt {
   static gap::generator<GotoStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<GotoStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<GotoStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<GotoStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::GOTO_STMT;
   }
diff --git a/include/multiplier/AST/GuardedByAttr.h b/include/multiplier/AST/GuardedByAttr.h
index 46487d7d7..a36d93b11 100644
--- a/include/multiplier/AST/GuardedByAttr.h
+++ b/include/multiplier/AST/GuardedByAttr.h
@@ -19,11 +19,6 @@ class File;
 class GuardedByAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT GuardedByAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/GuardedVarAttr.h b/include/multiplier/AST/GuardedVarAttr.h
index d32cd6cc2..bf25a4c9b 100644
--- a/include/multiplier/AST/GuardedVarAttr.h
+++ b/include/multiplier/AST/GuardedVarAttr.h
@@ -18,11 +18,6 @@ class File;
 class GuardedVarAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT GuardedVarAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/HIPManagedAttr.h b/include/multiplier/AST/HIPManagedAttr.h
index 19ba3e183..a52bc3526 100644
--- a/include/multiplier/AST/HIPManagedAttr.h
+++ b/include/multiplier/AST/HIPManagedAttr.h
@@ -18,11 +18,6 @@ class File;
 class HIPManagedAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HIPManagedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/HLSLAnnotationAttr.h b/include/multiplier/AST/HLSLAnnotationAttr.h
index 8d594c214..88b87b2c8 100644
--- a/include/multiplier/AST/HLSLAnnotationAttr.h
+++ b/include/multiplier/AST/HLSLAnnotationAttr.h
@@ -18,11 +18,6 @@ class File;
 class HLSLAnnotationAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLAnnotationAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/HLSLBufferDecl.h b/include/multiplier/AST/HLSLBufferDecl.h
index 75ab02824..52e0937fd 100644
--- a/include/multiplier/AST/HLSLBufferDecl.h
+++ b/include/multiplier/AST/HLSLBufferDecl.h
@@ -19,11 +19,6 @@ class HLSLBufferDecl;
 class NamedDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLBufferDecl : public NamedDecl {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT HLSLBufferDecl : public NamedDecl {
   static gap::generator<HLSLBufferDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<HLSLBufferDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<HLSLBufferDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<HLSLBufferDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::HLSL_BUFFER;
   }
diff --git a/include/multiplier/AST/HLSLGroupSharedAddressSpaceAttr.h b/include/multiplier/AST/HLSLGroupSharedAddressSpaceAttr.h
index 5a7df59e7..30c611b68 100644
--- a/include/multiplier/AST/HLSLGroupSharedAddressSpaceAttr.h
+++ b/include/multiplier/AST/HLSLGroupSharedAddressSpaceAttr.h
@@ -18,11 +18,6 @@ class File;
 class HLSLGroupSharedAddressSpaceAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLGroupSharedAddressSpaceAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/HLSLNumThreadsAttr.h b/include/multiplier/AST/HLSLNumThreadsAttr.h
index 1247a6c1b..9e8da1c39 100644
--- a/include/multiplier/AST/HLSLNumThreadsAttr.h
+++ b/include/multiplier/AST/HLSLNumThreadsAttr.h
@@ -18,11 +18,6 @@ class File;
 class HLSLNumThreadsAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLNumThreadsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/HLSLParamModifierAttr.h b/include/multiplier/AST/HLSLParamModifierAttr.h
index 12a556f90..e2c844bef 100644
--- a/include/multiplier/AST/HLSLParamModifierAttr.h
+++ b/include/multiplier/AST/HLSLParamModifierAttr.h
@@ -19,11 +19,6 @@ class File;
 class HLSLParamModifierAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLParamModifierAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/HLSLResourceAttr.h b/include/multiplier/AST/HLSLResourceAttr.h
index 7c47d30a0..283c49859 100644
--- a/include/multiplier/AST/HLSLResourceAttr.h
+++ b/include/multiplier/AST/HLSLResourceAttr.h
@@ -18,11 +18,6 @@ class File;
 class HLSLResourceAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLResourceAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/HLSLResourceBindingAttr.h b/include/multiplier/AST/HLSLResourceBindingAttr.h
index 9f909f551..465cb7695 100644
--- a/include/multiplier/AST/HLSLResourceBindingAttr.h
+++ b/include/multiplier/AST/HLSLResourceBindingAttr.h
@@ -18,11 +18,6 @@ class File;
 class HLSLResourceBindingAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLResourceBindingAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/HLSLSV_DispatchThreadIDAttr.h b/include/multiplier/AST/HLSLSV_DispatchThreadIDAttr.h
index bd62a21d4..3a9f42758 100644
--- a/include/multiplier/AST/HLSLSV_DispatchThreadIDAttr.h
+++ b/include/multiplier/AST/HLSLSV_DispatchThreadIDAttr.h
@@ -19,11 +19,6 @@ class HLSLAnnotationAttr;
 class HLSLSV_DispatchThreadIDAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLSV_DispatchThreadIDAttr : public HLSLAnnotationAttr {
  private:
diff --git a/include/multiplier/AST/HLSLSV_GroupIndexAttr.h b/include/multiplier/AST/HLSLSV_GroupIndexAttr.h
index 95a015460..2e5999d9c 100644
--- a/include/multiplier/AST/HLSLSV_GroupIndexAttr.h
+++ b/include/multiplier/AST/HLSLSV_GroupIndexAttr.h
@@ -19,11 +19,6 @@ class HLSLAnnotationAttr;
 class HLSLSV_GroupIndexAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLSV_GroupIndexAttr : public HLSLAnnotationAttr {
  private:
diff --git a/include/multiplier/AST/HLSLShaderAttr.h b/include/multiplier/AST/HLSLShaderAttr.h
index 3e034f855..d71326c89 100644
--- a/include/multiplier/AST/HLSLShaderAttr.h
+++ b/include/multiplier/AST/HLSLShaderAttr.h
@@ -19,11 +19,6 @@ class File;
 class HLSLShaderAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HLSLShaderAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/HotAttr.h b/include/multiplier/AST/HotAttr.h
index cb05d249d..e490a6ad5 100644
--- a/include/multiplier/AST/HotAttr.h
+++ b/include/multiplier/AST/HotAttr.h
@@ -18,11 +18,6 @@ class File;
 class HotAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT HotAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/IBActionAttr.h b/include/multiplier/AST/IBActionAttr.h
index 2ce5efbe6..7c5a0adfb 100644
--- a/include/multiplier/AST/IBActionAttr.h
+++ b/include/multiplier/AST/IBActionAttr.h
@@ -18,11 +18,6 @@ class File;
 class IBActionAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IBActionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/IBOutletAttr.h b/include/multiplier/AST/IBOutletAttr.h
index dcb567639..25c299a79 100644
--- a/include/multiplier/AST/IBOutletAttr.h
+++ b/include/multiplier/AST/IBOutletAttr.h
@@ -18,11 +18,6 @@ class File;
 class IBOutletAttr;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IBOutletAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/IBOutletCollectionAttr.h b/include/multiplier/AST/IBOutletCollectionAttr.h
index a71b3090e..5faac3584 100644
--- a/include/multiplier/AST/IBOutletCollectionAttr.h
+++ b/include/multiplier/AST/IBOutletCollectionAttr.h
@@ -19,11 +19,6 @@ class IBOutletCollectionAttr;
 class InheritableAttr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IBOutletCollectionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/IFuncAttr.h b/include/multiplier/AST/IFuncAttr.h
index 7d992dcae..5c35c95ce 100644
--- a/include/multiplier/AST/IFuncAttr.h
+++ b/include/multiplier/AST/IFuncAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class IFuncAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IFuncAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/IfStmt.h b/include/multiplier/AST/IfStmt.h
index 875ca09b1..00799ce13 100644
--- a/include/multiplier/AST/IfStmt.h
+++ b/include/multiplier/AST/IfStmt.h
@@ -22,11 +22,6 @@ class IfStmt;
 class Stmt;
 class Token;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IfStmt : public Stmt {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT IfStmt : public Stmt {
   static gap::generator<IfStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<IfStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<IfStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<IfStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::IF_STMT;
   }
diff --git a/include/multiplier/AST/ImaginaryLiteral.h b/include/multiplier/AST/ImaginaryLiteral.h
index c275e4d53..f44be3f6f 100644
--- a/include/multiplier/AST/ImaginaryLiteral.h
+++ b/include/multiplier/AST/ImaginaryLiteral.h
@@ -20,11 +20,6 @@ class ImaginaryLiteral;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ImaginaryLiteral : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ImaginaryLiteral : public Expr {
   static gap::generator<ImaginaryLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ImaginaryLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<ImaginaryLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ImaginaryLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::IMAGINARY_LITERAL;
   }
diff --git a/include/multiplier/AST/ImplicitCastExpr.h b/include/multiplier/AST/ImplicitCastExpr.h
index f2a6e32ec..1c0125038 100644
--- a/include/multiplier/AST/ImplicitCastExpr.h
+++ b/include/multiplier/AST/ImplicitCastExpr.h
@@ -21,11 +21,6 @@ class ImplicitCastExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ImplicitCastExpr : public CastExpr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT ImplicitCastExpr : public CastExpr {
   static gap::generator<ImplicitCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ImplicitCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ImplicitCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ImplicitCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::IMPLICIT_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/ImplicitConceptSpecializationDecl.h b/include/multiplier/AST/ImplicitConceptSpecializationDecl.h
index 288b0e444..5ca4c727a 100644
--- a/include/multiplier/AST/ImplicitConceptSpecializationDecl.h
+++ b/include/multiplier/AST/ImplicitConceptSpecializationDecl.h
@@ -19,11 +19,6 @@ class ImplicitConceptSpecializationDecl;
 class Stmt;
 class TemplateArgument;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ImplicitConceptSpecializationDecl : public Decl {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT ImplicitConceptSpecializationDecl : public Decl {
   static gap::generator<ImplicitConceptSpecializationDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ImplicitConceptSpecializationDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ImplicitConceptSpecializationDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ImplicitConceptSpecializationDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::IMPLICIT_CONCEPT_SPECIALIZATION;
   }
diff --git a/include/multiplier/AST/ImplicitParamDecl.h b/include/multiplier/AST/ImplicitParamDecl.h
index b98c934d1..f3aa38dcd 100644
--- a/include/multiplier/AST/ImplicitParamDecl.h
+++ b/include/multiplier/AST/ImplicitParamDecl.h
@@ -23,11 +23,6 @@ class Stmt;
 class Token;
 class ValueDecl;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ImplicitParamDecl : public VarDecl {
  private:
@@ -44,8 +39,7 @@ class MX_EXPORT ImplicitParamDecl : public VarDecl {
   static gap::generator<ImplicitParamDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ImplicitParamDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ImplicitParamDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ImplicitParamDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::IMPLICIT_PARAM;
   }
diff --git a/include/multiplier/AST/ImplicitValueInitExpr.h b/include/multiplier/AST/ImplicitValueInitExpr.h
index 7eae1e627..d239b8778 100644
--- a/include/multiplier/AST/ImplicitValueInitExpr.h
+++ b/include/multiplier/AST/ImplicitValueInitExpr.h
@@ -20,11 +20,6 @@ class ImplicitValueInitExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ImplicitValueInitExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ImplicitValueInitExpr : public Expr {
   static gap::generator<ImplicitValueInitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ImplicitValueInitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ImplicitValueInitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ImplicitValueInitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::IMPLICIT_VALUE_INIT_EXPR;
   }
diff --git a/include/multiplier/AST/ImportDecl.h b/include/multiplier/AST/ImportDecl.h
index 688d8f0a2..0cde8e521 100644
--- a/include/multiplier/AST/ImportDecl.h
+++ b/include/multiplier/AST/ImportDecl.h
@@ -19,11 +19,6 @@ class ImportDecl;
 class Stmt;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ImportDecl : public Decl {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT ImportDecl : public Decl {
   static gap::generator<ImportDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ImportDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ImportDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ImportDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::IMPORT;
   }
diff --git a/include/multiplier/AST/IncompleteArrayType.h b/include/multiplier/AST/IncompleteArrayType.h
index 1ae03d128..774659acb 100644
--- a/include/multiplier/AST/IncompleteArrayType.h
+++ b/include/multiplier/AST/IncompleteArrayType.h
@@ -17,11 +17,6 @@ class ArrayType;
 class IncompleteArrayType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IncompleteArrayType : public ArrayType {
  private:
diff --git a/include/multiplier/AST/IndirectFieldDecl.h b/include/multiplier/AST/IndirectFieldDecl.h
index 6e5098c9a..562b879dd 100644
--- a/include/multiplier/AST/IndirectFieldDecl.h
+++ b/include/multiplier/AST/IndirectFieldDecl.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class ValueDecl;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IndirectFieldDecl : public ValueDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT IndirectFieldDecl : public ValueDecl {
   static gap::generator<IndirectFieldDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<IndirectFieldDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<IndirectFieldDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<IndirectFieldDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::INDIRECT_FIELD;
   }
diff --git a/include/multiplier/AST/IndirectGotoStmt.h b/include/multiplier/AST/IndirectGotoStmt.h
index 8416a78d3..dbd7f8ad2 100644
--- a/include/multiplier/AST/IndirectGotoStmt.h
+++ b/include/multiplier/AST/IndirectGotoStmt.h
@@ -20,11 +20,6 @@ class IndirectGotoStmt;
 class LabelDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IndirectGotoStmt : public Stmt {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT IndirectGotoStmt : public Stmt {
   static gap::generator<IndirectGotoStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<IndirectGotoStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<IndirectGotoStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<IndirectGotoStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::INDIRECT_GOTO_STMT;
   }
diff --git a/include/multiplier/AST/InheritableAttr.h b/include/multiplier/AST/InheritableAttr.h
index 241e11fd9..d9c4c4d7b 100644
--- a/include/multiplier/AST/InheritableAttr.h
+++ b/include/multiplier/AST/InheritableAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class InheritableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT InheritableAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/InheritableParamAttr.h b/include/multiplier/AST/InheritableParamAttr.h
index 94aa9b7f7..8e1be7afe 100644
--- a/include/multiplier/AST/InheritableParamAttr.h
+++ b/include/multiplier/AST/InheritableParamAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class InheritableParamAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT InheritableParamAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/InitListExpr.h b/include/multiplier/AST/InitListExpr.h
index 8280513ba..bab033d26 100644
--- a/include/multiplier/AST/InitListExpr.h
+++ b/include/multiplier/AST/InitListExpr.h
@@ -21,11 +21,6 @@ class InitListExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT InitListExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT InitListExpr : public Expr {
   static gap::generator<InitListExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<InitListExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<InitListExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<InitListExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::INIT_LIST_EXPR;
   }
diff --git a/include/multiplier/AST/InitPriorityAttr.h b/include/multiplier/AST/InitPriorityAttr.h
index 49e7dd84c..8266b1015 100644
--- a/include/multiplier/AST/InitPriorityAttr.h
+++ b/include/multiplier/AST/InitPriorityAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class InitPriorityAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT InitPriorityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/InitSegAttr.h b/include/multiplier/AST/InitSegAttr.h
index e1c926f80..acca6c088 100644
--- a/include/multiplier/AST/InitSegAttr.h
+++ b/include/multiplier/AST/InitSegAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class InitSegAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT InitSegAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/InjectedClassNameType.h b/include/multiplier/AST/InjectedClassNameType.h
index a361196e3..a1a62b0c5 100644
--- a/include/multiplier/AST/InjectedClassNameType.h
+++ b/include/multiplier/AST/InjectedClassNameType.h
@@ -18,11 +18,6 @@ class InjectedClassNameType;
 class TemplateSpecializationType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT InjectedClassNameType : public Type {
  private:
diff --git a/include/multiplier/AST/IntegerLiteral.h b/include/multiplier/AST/IntegerLiteral.h
index 40ac57e28..95a48f7f6 100644
--- a/include/multiplier/AST/IntegerLiteral.h
+++ b/include/multiplier/AST/IntegerLiteral.h
@@ -20,11 +20,6 @@ class IntegerLiteral;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IntegerLiteral : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT IntegerLiteral : public Expr {
   static gap::generator<IntegerLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<IntegerLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<IntegerLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<IntegerLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::INTEGER_LITERAL;
   }
diff --git a/include/multiplier/AST/IntelOclBiccAttr.h b/include/multiplier/AST/IntelOclBiccAttr.h
index 7cf43345e..679a145ef 100644
--- a/include/multiplier/AST/IntelOclBiccAttr.h
+++ b/include/multiplier/AST/IntelOclBiccAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class IntelOclBiccAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IntelOclBiccAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/InternalLinkageAttr.h b/include/multiplier/AST/InternalLinkageAttr.h
index 5b5dc0879..869866aae 100644
--- a/include/multiplier/AST/InternalLinkageAttr.h
+++ b/include/multiplier/AST/InternalLinkageAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class InternalLinkageAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT InternalLinkageAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/LTOVisibilityPublicAttr.h b/include/multiplier/AST/LTOVisibilityPublicAttr.h
index fa44df510..8dacec19a 100644
--- a/include/multiplier/AST/LTOVisibilityPublicAttr.h
+++ b/include/multiplier/AST/LTOVisibilityPublicAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class LTOVisibilityPublicAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LTOVisibilityPublicAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/LValueReferenceType.h b/include/multiplier/AST/LValueReferenceType.h
index 44c869692..ca4b8ac5d 100644
--- a/include/multiplier/AST/LValueReferenceType.h
+++ b/include/multiplier/AST/LValueReferenceType.h
@@ -17,11 +17,6 @@ class LValueReferenceType;
 class ReferenceType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LValueReferenceType : public ReferenceType {
  private:
diff --git a/include/multiplier/AST/LabelDecl.h b/include/multiplier/AST/LabelDecl.h
index 5cfb9c5b5..c6bfe5942 100644
--- a/include/multiplier/AST/LabelDecl.h
+++ b/include/multiplier/AST/LabelDecl.h
@@ -20,11 +20,6 @@ class LabelStmt;
 class NamedDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LabelDecl : public NamedDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT LabelDecl : public NamedDecl {
   static gap::generator<LabelDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<LabelDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<LabelDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<LabelDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::LABEL;
   }
diff --git a/include/multiplier/AST/LabelStmt.h b/include/multiplier/AST/LabelStmt.h
index a8786fa49..a6473b88c 100644
--- a/include/multiplier/AST/LabelStmt.h
+++ b/include/multiplier/AST/LabelStmt.h
@@ -20,11 +20,6 @@ class LabelStmt;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LabelStmt : public ValueStmt {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT LabelStmt : public ValueStmt {
   static gap::generator<LabelStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<LabelStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<LabelStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<LabelStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::LABEL_STMT;
   }
diff --git a/include/multiplier/AST/LambdaExpr.h b/include/multiplier/AST/LambdaExpr.h
index d3297bbaf..91adf51ac 100644
--- a/include/multiplier/AST/LambdaExpr.h
+++ b/include/multiplier/AST/LambdaExpr.h
@@ -28,11 +28,6 @@ class TemplateParameterList;
 class Token;
 class TokenRange;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LambdaExpr : public Expr {
  private:
@@ -47,8 +42,7 @@ class MX_EXPORT LambdaExpr : public Expr {
   static gap::generator<LambdaExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<LambdaExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<LambdaExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<LambdaExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::LAMBDA_EXPR;
   }
diff --git a/include/multiplier/AST/LayoutVersionAttr.h b/include/multiplier/AST/LayoutVersionAttr.h
index 015af6fde..6a947b702 100644
--- a/include/multiplier/AST/LayoutVersionAttr.h
+++ b/include/multiplier/AST/LayoutVersionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class LayoutVersionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LayoutVersionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/LeafAttr.h b/include/multiplier/AST/LeafAttr.h
index 6a09a0b4d..b5e8d504a 100644
--- a/include/multiplier/AST/LeafAttr.h
+++ b/include/multiplier/AST/LeafAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class LeafAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LeafAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/LifetimeBoundAttr.h b/include/multiplier/AST/LifetimeBoundAttr.h
index a21897991..22c117a21 100644
--- a/include/multiplier/AST/LifetimeBoundAttr.h
+++ b/include/multiplier/AST/LifetimeBoundAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class LifetimeBoundAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LifetimeBoundAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/LifetimeExtendedTemporaryDecl.h b/include/multiplier/AST/LifetimeExtendedTemporaryDecl.h
index 475f2930d..c26186781 100644
--- a/include/multiplier/AST/LifetimeExtendedTemporaryDecl.h
+++ b/include/multiplier/AST/LifetimeExtendedTemporaryDecl.h
@@ -21,11 +21,6 @@ class LifetimeExtendedTemporaryDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LifetimeExtendedTemporaryDecl : public Decl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT LifetimeExtendedTemporaryDecl : public Decl {
   static gap::generator<LifetimeExtendedTemporaryDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<LifetimeExtendedTemporaryDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<LifetimeExtendedTemporaryDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<LifetimeExtendedTemporaryDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::LIFETIME_EXTENDED_TEMPORARY;
   }
diff --git a/include/multiplier/AST/LikelyAttr.h b/include/multiplier/AST/LikelyAttr.h
index 108031bbc..c804a7b0b 100644
--- a/include/multiplier/AST/LikelyAttr.h
+++ b/include/multiplier/AST/LikelyAttr.h
@@ -18,11 +18,6 @@ class File;
 class LikelyAttr;
 class StmtAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LikelyAttr : public StmtAttr {
  private:
diff --git a/include/multiplier/AST/LinkageSpecDecl.h b/include/multiplier/AST/LinkageSpecDecl.h
index 490a41814..5319914fc 100644
--- a/include/multiplier/AST/LinkageSpecDecl.h
+++ b/include/multiplier/AST/LinkageSpecDecl.h
@@ -20,11 +20,6 @@ class File;
 class LinkageSpecDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LinkageSpecDecl : public Decl {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT LinkageSpecDecl : public Decl {
   static gap::generator<LinkageSpecDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<LinkageSpecDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<LinkageSpecDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<LinkageSpecDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::LINKAGE_SPEC;
   }
diff --git a/include/multiplier/AST/LoaderUninitializedAttr.h b/include/multiplier/AST/LoaderUninitializedAttr.h
index c82c2592d..50af367e9 100644
--- a/include/multiplier/AST/LoaderUninitializedAttr.h
+++ b/include/multiplier/AST/LoaderUninitializedAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class LoaderUninitializedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LoaderUninitializedAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/LockReturnedAttr.h b/include/multiplier/AST/LockReturnedAttr.h
index 8136b056e..3161185ef 100644
--- a/include/multiplier/AST/LockReturnedAttr.h
+++ b/include/multiplier/AST/LockReturnedAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class LockReturnedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LockReturnedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/LocksExcludedAttr.h b/include/multiplier/AST/LocksExcludedAttr.h
index b51c97942..e8346bd88 100644
--- a/include/multiplier/AST/LocksExcludedAttr.h
+++ b/include/multiplier/AST/LocksExcludedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class LocksExcludedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LocksExcludedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/LoopHintAttr.h b/include/multiplier/AST/LoopHintAttr.h
index 95a9ec288..f431ac203 100644
--- a/include/multiplier/AST/LoopHintAttr.h
+++ b/include/multiplier/AST/LoopHintAttr.h
@@ -21,11 +21,6 @@ class Expr;
 class File;
 class LoopHintAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT LoopHintAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/M68kInterruptAttr.h b/include/multiplier/AST/M68kInterruptAttr.h
index 28bf91f59..d66a52da9 100644
--- a/include/multiplier/AST/M68kInterruptAttr.h
+++ b/include/multiplier/AST/M68kInterruptAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class M68kInterruptAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT M68kInterruptAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/M68kRTDAttr.h b/include/multiplier/AST/M68kRTDAttr.h
index 73364f10f..9020f324d 100644
--- a/include/multiplier/AST/M68kRTDAttr.h
+++ b/include/multiplier/AST/M68kRTDAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class M68kRTDAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT M68kRTDAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MIGServerRoutineAttr.h b/include/multiplier/AST/MIGServerRoutineAttr.h
index 781363627..6c4657952 100644
--- a/include/multiplier/AST/MIGServerRoutineAttr.h
+++ b/include/multiplier/AST/MIGServerRoutineAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MIGServerRoutineAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MIGServerRoutineAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MSABIAttr.h b/include/multiplier/AST/MSABIAttr.h
index 2c50da64b..338a761f6 100644
--- a/include/multiplier/AST/MSABIAttr.h
+++ b/include/multiplier/AST/MSABIAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MSABIAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSABIAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MSAllocatorAttr.h b/include/multiplier/AST/MSAllocatorAttr.h
index 3614b5739..afdc28bc3 100644
--- a/include/multiplier/AST/MSAllocatorAttr.h
+++ b/include/multiplier/AST/MSAllocatorAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MSAllocatorAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSAllocatorAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MSAsmStmt.h b/include/multiplier/AST/MSAsmStmt.h
index 72346976c..52e12fbfc 100644
--- a/include/multiplier/AST/MSAsmStmt.h
+++ b/include/multiplier/AST/MSAsmStmt.h
@@ -20,11 +20,6 @@ class File;
 class MSAsmStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSAsmStmt : public AsmStmt {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT MSAsmStmt : public AsmStmt {
   static gap::generator<MSAsmStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<MSAsmStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<MSAsmStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<MSAsmStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::MS_ASM_STMT;
   }
diff --git a/include/multiplier/AST/MSConstexprAttr.h b/include/multiplier/AST/MSConstexprAttr.h
index b91d77e90..e3cec06c2 100644
--- a/include/multiplier/AST/MSConstexprAttr.h
+++ b/include/multiplier/AST/MSConstexprAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MSConstexprAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSConstexprAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MSDependentExistsStmt.h b/include/multiplier/AST/MSDependentExistsStmt.h
index 54946abbb..0286a09dd 100644
--- a/include/multiplier/AST/MSDependentExistsStmt.h
+++ b/include/multiplier/AST/MSDependentExistsStmt.h
@@ -19,11 +19,6 @@ class File;
 class MSDependentExistsStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSDependentExistsStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT MSDependentExistsStmt : public Stmt {
   static gap::generator<MSDependentExistsStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<MSDependentExistsStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<MSDependentExistsStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<MSDependentExistsStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::MS_DEPENDENT_EXISTS_STMT;
   }
diff --git a/include/multiplier/AST/MSGuidDecl.h b/include/multiplier/AST/MSGuidDecl.h
index 1596b43a9..ca0a54139 100644
--- a/include/multiplier/AST/MSGuidDecl.h
+++ b/include/multiplier/AST/MSGuidDecl.h
@@ -20,11 +20,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSGuidDecl : public ValueDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT MSGuidDecl : public ValueDecl {
   static gap::generator<MSGuidDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<MSGuidDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<MSGuidDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<MSGuidDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::MS_GUID;
   }
diff --git a/include/multiplier/AST/MSInheritanceAttr.h b/include/multiplier/AST/MSInheritanceAttr.h
index 803f64a94..8293fde9c 100644
--- a/include/multiplier/AST/MSInheritanceAttr.h
+++ b/include/multiplier/AST/MSInheritanceAttr.h
@@ -20,11 +20,6 @@ class File;
 class InheritableAttr;
 class MSInheritanceAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSInheritanceAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MSNoVTableAttr.h b/include/multiplier/AST/MSNoVTableAttr.h
index da0fcb469..4397312c9 100644
--- a/include/multiplier/AST/MSNoVTableAttr.h
+++ b/include/multiplier/AST/MSNoVTableAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MSNoVTableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSNoVTableAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MSP430InterruptAttr.h b/include/multiplier/AST/MSP430InterruptAttr.h
index b016bf1b4..fed39675b 100644
--- a/include/multiplier/AST/MSP430InterruptAttr.h
+++ b/include/multiplier/AST/MSP430InterruptAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MSP430InterruptAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSP430InterruptAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MSPropertyDecl.h b/include/multiplier/AST/MSPropertyDecl.h
index a06584dae..0aa2045ca 100644
--- a/include/multiplier/AST/MSPropertyDecl.h
+++ b/include/multiplier/AST/MSPropertyDecl.h
@@ -21,11 +21,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSPropertyDecl : public DeclaratorDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT MSPropertyDecl : public DeclaratorDecl {
   static gap::generator<MSPropertyDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<MSPropertyDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<MSPropertyDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<MSPropertyDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::MS_PROPERTY;
   }
diff --git a/include/multiplier/AST/MSPropertyRefExpr.h b/include/multiplier/AST/MSPropertyRefExpr.h
index 009e56c03..af091dcac 100644
--- a/include/multiplier/AST/MSPropertyRefExpr.h
+++ b/include/multiplier/AST/MSPropertyRefExpr.h
@@ -21,11 +21,6 @@ class MSPropertyRefExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSPropertyRefExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT MSPropertyRefExpr : public Expr {
   static gap::generator<MSPropertyRefExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<MSPropertyRefExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<MSPropertyRefExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<MSPropertyRefExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::MS_PROPERTY_REF_EXPR;
   }
diff --git a/include/multiplier/AST/MSPropertySubscriptExpr.h b/include/multiplier/AST/MSPropertySubscriptExpr.h
index 16edab3cc..6f9ad7254 100644
--- a/include/multiplier/AST/MSPropertySubscriptExpr.h
+++ b/include/multiplier/AST/MSPropertySubscriptExpr.h
@@ -20,11 +20,6 @@ class MSPropertySubscriptExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSPropertySubscriptExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT MSPropertySubscriptExpr : public Expr {
   static gap::generator<MSPropertySubscriptExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<MSPropertySubscriptExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<MSPropertySubscriptExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<MSPropertySubscriptExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::MS_PROPERTY_SUBSCRIPT_EXPR;
   }
diff --git a/include/multiplier/AST/MSStructAttr.h b/include/multiplier/AST/MSStructAttr.h
index c387bca63..aca4c90df 100644
--- a/include/multiplier/AST/MSStructAttr.h
+++ b/include/multiplier/AST/MSStructAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MSStructAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSStructAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MSVtorDispAttr.h b/include/multiplier/AST/MSVtorDispAttr.h
index 69fe9b265..fb7f0b50e 100644
--- a/include/multiplier/AST/MSVtorDispAttr.h
+++ b/include/multiplier/AST/MSVtorDispAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class MSVtorDispAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MSVtorDispAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MacroQualifiedType.h b/include/multiplier/AST/MacroQualifiedType.h
index 34f232b51..3f832d4cb 100644
--- a/include/multiplier/AST/MacroQualifiedType.h
+++ b/include/multiplier/AST/MacroQualifiedType.h
@@ -16,11 +16,6 @@ class Index;
 class MacroQualifiedType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroQualifiedType : public Type {
  private:
diff --git a/include/multiplier/AST/MaterializeTemporaryExpr.h b/include/multiplier/AST/MaterializeTemporaryExpr.h
index fc7da43ec..07794c08d 100644
--- a/include/multiplier/AST/MaterializeTemporaryExpr.h
+++ b/include/multiplier/AST/MaterializeTemporaryExpr.h
@@ -23,11 +23,6 @@ class Stmt;
 class Token;
 class ValueDecl;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MaterializeTemporaryExpr : public Expr {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT MaterializeTemporaryExpr : public Expr {
   static gap::generator<MaterializeTemporaryExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<MaterializeTemporaryExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<MaterializeTemporaryExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<MaterializeTemporaryExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::MATERIALIZE_TEMPORARY_EXPR;
   }
diff --git a/include/multiplier/AST/MatrixSubscriptExpr.h b/include/multiplier/AST/MatrixSubscriptExpr.h
index 2cc28ae9c..e0e578ed8 100644
--- a/include/multiplier/AST/MatrixSubscriptExpr.h
+++ b/include/multiplier/AST/MatrixSubscriptExpr.h
@@ -20,11 +20,6 @@ class MatrixSubscriptExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MatrixSubscriptExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT MatrixSubscriptExpr : public Expr {
   static gap::generator<MatrixSubscriptExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<MatrixSubscriptExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<MatrixSubscriptExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<MatrixSubscriptExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::MATRIX_SUBSCRIPT_EXPR;
   }
diff --git a/include/multiplier/AST/MatrixType.h b/include/multiplier/AST/MatrixType.h
index 4f07d3541..3934c6dba 100644
--- a/include/multiplier/AST/MatrixType.h
+++ b/include/multiplier/AST/MatrixType.h
@@ -16,11 +16,6 @@ class Index;
 class MatrixType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MatrixType : public Type {
  private:
diff --git a/include/multiplier/AST/MaxFieldAlignmentAttr.h b/include/multiplier/AST/MaxFieldAlignmentAttr.h
index d7597078d..f5c058bbf 100644
--- a/include/multiplier/AST/MaxFieldAlignmentAttr.h
+++ b/include/multiplier/AST/MaxFieldAlignmentAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MaxFieldAlignmentAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MaxFieldAlignmentAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MayAliasAttr.h b/include/multiplier/AST/MayAliasAttr.h
index c7ba9401d..dc222e018 100644
--- a/include/multiplier/AST/MayAliasAttr.h
+++ b/include/multiplier/AST/MayAliasAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MayAliasAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MayAliasAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MaybeUndefAttr.h b/include/multiplier/AST/MaybeUndefAttr.h
index 89d009d4b..ef591a684 100644
--- a/include/multiplier/AST/MaybeUndefAttr.h
+++ b/include/multiplier/AST/MaybeUndefAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MaybeUndefAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MaybeUndefAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MemberExpr.h b/include/multiplier/AST/MemberExpr.h
index 96ee1b80f..2f8a6ad3e 100644
--- a/include/multiplier/AST/MemberExpr.h
+++ b/include/multiplier/AST/MemberExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class ValueDecl;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MemberExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT MemberExpr : public Expr {
   static gap::generator<MemberExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<MemberExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<MemberExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<MemberExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::MEMBER_EXPR;
   }
diff --git a/include/multiplier/AST/MemberPointerType.h b/include/multiplier/AST/MemberPointerType.h
index dbd4629bf..a30150c5c 100644
--- a/include/multiplier/AST/MemberPointerType.h
+++ b/include/multiplier/AST/MemberPointerType.h
@@ -16,11 +16,6 @@ class Index;
 class MemberPointerType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MemberPointerType : public Type {
  private:
diff --git a/include/multiplier/AST/MicroMipsAttr.h b/include/multiplier/AST/MicroMipsAttr.h
index daef376f5..4e59321d7 100644
--- a/include/multiplier/AST/MicroMipsAttr.h
+++ b/include/multiplier/AST/MicroMipsAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MicroMipsAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MicroMipsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MinSizeAttr.h b/include/multiplier/AST/MinSizeAttr.h
index 7d3027726..4c26b4150 100644
--- a/include/multiplier/AST/MinSizeAttr.h
+++ b/include/multiplier/AST/MinSizeAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MinSizeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MinSizeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MinVectorWidthAttr.h b/include/multiplier/AST/MinVectorWidthAttr.h
index fad8c4ce7..d211c9907 100644
--- a/include/multiplier/AST/MinVectorWidthAttr.h
+++ b/include/multiplier/AST/MinVectorWidthAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class MinVectorWidthAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MinVectorWidthAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/Mips16Attr.h b/include/multiplier/AST/Mips16Attr.h
index 49cec7108..4c412af43 100644
--- a/include/multiplier/AST/Mips16Attr.h
+++ b/include/multiplier/AST/Mips16Attr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Mips16Attr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT Mips16Attr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MipsInterruptAttr.h b/include/multiplier/AST/MipsInterruptAttr.h
index 2257c100b..bcdb5d906 100644
--- a/include/multiplier/AST/MipsInterruptAttr.h
+++ b/include/multiplier/AST/MipsInterruptAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class MipsInterruptAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MipsInterruptAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MipsLongCallAttr.h b/include/multiplier/AST/MipsLongCallAttr.h
index 093bc7493..98c907d88 100644
--- a/include/multiplier/AST/MipsLongCallAttr.h
+++ b/include/multiplier/AST/MipsLongCallAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class MipsLongCallAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MipsLongCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/MipsShortCallAttr.h b/include/multiplier/AST/MipsShortCallAttr.h
index 70775cd7e..c355aa886 100644
--- a/include/multiplier/AST/MipsShortCallAttr.h
+++ b/include/multiplier/AST/MipsShortCallAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class MipsShortCallAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MipsShortCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ModeAttr.h b/include/multiplier/AST/ModeAttr.h
index a7a6f832b..a009cd02c 100644
--- a/include/multiplier/AST/ModeAttr.h
+++ b/include/multiplier/AST/ModeAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ModeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ModeAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/MustTailAttr.h b/include/multiplier/AST/MustTailAttr.h
index 14978f13a..3ea6a96c2 100644
--- a/include/multiplier/AST/MustTailAttr.h
+++ b/include/multiplier/AST/MustTailAttr.h
@@ -18,11 +18,6 @@ class File;
 class MustTailAttr;
 class StmtAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MustTailAttr : public StmtAttr {
  private:
diff --git a/include/multiplier/AST/NSConsumedAttr.h b/include/multiplier/AST/NSConsumedAttr.h
index e1e7650b9..243cc4532 100644
--- a/include/multiplier/AST/NSConsumedAttr.h
+++ b/include/multiplier/AST/NSConsumedAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class InheritableParamAttr;
 class NSConsumedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NSConsumedAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/NSConsumesSelfAttr.h b/include/multiplier/AST/NSConsumesSelfAttr.h
index 3b19c9d05..937eeaa46 100644
--- a/include/multiplier/AST/NSConsumesSelfAttr.h
+++ b/include/multiplier/AST/NSConsumesSelfAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NSConsumesSelfAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NSConsumesSelfAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NSErrorDomainAttr.h b/include/multiplier/AST/NSErrorDomainAttr.h
index eee75f95c..f1dd59cd4 100644
--- a/include/multiplier/AST/NSErrorDomainAttr.h
+++ b/include/multiplier/AST/NSErrorDomainAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NSErrorDomainAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NSErrorDomainAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NSReturnsAutoreleasedAttr.h b/include/multiplier/AST/NSReturnsAutoreleasedAttr.h
index 0593465f8..af99cface 100644
--- a/include/multiplier/AST/NSReturnsAutoreleasedAttr.h
+++ b/include/multiplier/AST/NSReturnsAutoreleasedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NSReturnsAutoreleasedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NSReturnsAutoreleasedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NSReturnsNotRetainedAttr.h b/include/multiplier/AST/NSReturnsNotRetainedAttr.h
index 21dc8c791..fd0ab1d40 100644
--- a/include/multiplier/AST/NSReturnsNotRetainedAttr.h
+++ b/include/multiplier/AST/NSReturnsNotRetainedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NSReturnsNotRetainedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NSReturnsNotRetainedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NSReturnsRetainedAttr.h b/include/multiplier/AST/NSReturnsRetainedAttr.h
index 597275a40..e00fa2e92 100644
--- a/include/multiplier/AST/NSReturnsRetainedAttr.h
+++ b/include/multiplier/AST/NSReturnsRetainedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NSReturnsRetainedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NSReturnsRetainedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NVPTXKernelAttr.h b/include/multiplier/AST/NVPTXKernelAttr.h
index 02410106f..e425e07b5 100644
--- a/include/multiplier/AST/NVPTXKernelAttr.h
+++ b/include/multiplier/AST/NVPTXKernelAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NVPTXKernelAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NVPTXKernelAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NakedAttr.h b/include/multiplier/AST/NakedAttr.h
index 8ae2cc382..930286069 100644
--- a/include/multiplier/AST/NakedAttr.h
+++ b/include/multiplier/AST/NakedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NakedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NakedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NamedDecl.h b/include/multiplier/AST/NamedDecl.h
index f0f0c20b3..8bcf6fb0f 100644
--- a/include/multiplier/AST/NamedDecl.h
+++ b/include/multiplier/AST/NamedDecl.h
@@ -22,11 +22,6 @@ class NamedDecl;
 class QualifiedNameRenderOptions;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NamedDecl : public Decl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT NamedDecl : public Decl {
   static gap::generator<NamedDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<NamedDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<NamedDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<NamedDecl> in(const Compilation &tu);
   static gap::generator<NamedDecl> containing(const Decl &decl);
   static gap::generator<NamedDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/NamespaceAliasDecl.h b/include/multiplier/AST/NamespaceAliasDecl.h
index 349dd4768..bb58730ff 100644
--- a/include/multiplier/AST/NamespaceAliasDecl.h
+++ b/include/multiplier/AST/NamespaceAliasDecl.h
@@ -20,11 +20,6 @@ class NamespaceAliasDecl;
 class NamespaceDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NamespaceAliasDecl : public NamedDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT NamespaceAliasDecl : public NamedDecl {
   static gap::generator<NamespaceAliasDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<NamespaceAliasDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<NamespaceAliasDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<NamespaceAliasDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::NAMESPACE_ALIAS;
   }
diff --git a/include/multiplier/AST/NamespaceDecl.h b/include/multiplier/AST/NamespaceDecl.h
index 50c4af493..9dbe5867e 100644
--- a/include/multiplier/AST/NamespaceDecl.h
+++ b/include/multiplier/AST/NamespaceDecl.h
@@ -20,11 +20,6 @@ class NamedDecl;
 class NamespaceDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NamespaceDecl : public NamedDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT NamespaceDecl : public NamedDecl {
   static gap::generator<NamespaceDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<NamespaceDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<NamespaceDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<NamespaceDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::NAMESPACE;
   }
diff --git a/include/multiplier/AST/NoAliasAttr.h b/include/multiplier/AST/NoAliasAttr.h
index 3c7f7a169..60f824e04 100644
--- a/include/multiplier/AST/NoAliasAttr.h
+++ b/include/multiplier/AST/NoAliasAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoAliasAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoAliasAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoBuiltinAttr.h b/include/multiplier/AST/NoBuiltinAttr.h
index 9274017e6..391d1e348 100644
--- a/include/multiplier/AST/NoBuiltinAttr.h
+++ b/include/multiplier/AST/NoBuiltinAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class NoBuiltinAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoBuiltinAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/NoCommonAttr.h b/include/multiplier/AST/NoCommonAttr.h
index 0db2c1342..fdfb63691 100644
--- a/include/multiplier/AST/NoCommonAttr.h
+++ b/include/multiplier/AST/NoCommonAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoCommonAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoCommonAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoDebugAttr.h b/include/multiplier/AST/NoDebugAttr.h
index 4c6c11608..edf8fd76e 100644
--- a/include/multiplier/AST/NoDebugAttr.h
+++ b/include/multiplier/AST/NoDebugAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoDebugAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoDebugAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoDerefAttr.h b/include/multiplier/AST/NoDerefAttr.h
index fe34f7608..d3a630c18 100644
--- a/include/multiplier/AST/NoDerefAttr.h
+++ b/include/multiplier/AST/NoDerefAttr.h
@@ -18,11 +18,6 @@ class File;
 class NoDerefAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoDerefAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/NoDestroyAttr.h b/include/multiplier/AST/NoDestroyAttr.h
index ad2434623..4e3ea4f81 100644
--- a/include/multiplier/AST/NoDestroyAttr.h
+++ b/include/multiplier/AST/NoDestroyAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoDestroyAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoDestroyAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoDuplicateAttr.h b/include/multiplier/AST/NoDuplicateAttr.h
index 93a9372aa..2d1450b83 100644
--- a/include/multiplier/AST/NoDuplicateAttr.h
+++ b/include/multiplier/AST/NoDuplicateAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoDuplicateAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoDuplicateAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoEscapeAttr.h b/include/multiplier/AST/NoEscapeAttr.h
index e0f47ce66..25c6b6614 100644
--- a/include/multiplier/AST/NoEscapeAttr.h
+++ b/include/multiplier/AST/NoEscapeAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class NoEscapeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoEscapeAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/NoInitExpr.h b/include/multiplier/AST/NoInitExpr.h
index b3c667e06..dc8f04e04 100644
--- a/include/multiplier/AST/NoInitExpr.h
+++ b/include/multiplier/AST/NoInitExpr.h
@@ -20,11 +20,6 @@ class NoInitExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoInitExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT NoInitExpr : public Expr {
   static gap::generator<NoInitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<NoInitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<NoInitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<NoInitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::NO_INIT_EXPR;
   }
diff --git a/include/multiplier/AST/NoInlineAttr.h b/include/multiplier/AST/NoInlineAttr.h
index 5fcf6afa0..f23de213e 100644
--- a/include/multiplier/AST/NoInlineAttr.h
+++ b/include/multiplier/AST/NoInlineAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class NoInlineAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoInlineAttr : public DeclOrStmtAttr {
  private:
diff --git a/include/multiplier/AST/NoInstrumentFunctionAttr.h b/include/multiplier/AST/NoInstrumentFunctionAttr.h
index 625f40d5d..1a63dbcf0 100644
--- a/include/multiplier/AST/NoInstrumentFunctionAttr.h
+++ b/include/multiplier/AST/NoInstrumentFunctionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoInstrumentFunctionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoInstrumentFunctionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoMergeAttr.h b/include/multiplier/AST/NoMergeAttr.h
index 7d4b3f54f..191767e1b 100644
--- a/include/multiplier/AST/NoMergeAttr.h
+++ b/include/multiplier/AST/NoMergeAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class NoMergeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoMergeAttr : public DeclOrStmtAttr {
  private:
diff --git a/include/multiplier/AST/NoMicroMipsAttr.h b/include/multiplier/AST/NoMicroMipsAttr.h
index 2c90a9568..3fa6b53bc 100644
--- a/include/multiplier/AST/NoMicroMipsAttr.h
+++ b/include/multiplier/AST/NoMicroMipsAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoMicroMipsAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoMicroMipsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoMips16Attr.h b/include/multiplier/AST/NoMips16Attr.h
index 16923f495..897ffe196 100644
--- a/include/multiplier/AST/NoMips16Attr.h
+++ b/include/multiplier/AST/NoMips16Attr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoMips16Attr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoMips16Attr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoProfileFunctionAttr.h b/include/multiplier/AST/NoProfileFunctionAttr.h
index 919e814d4..991dfc598 100644
--- a/include/multiplier/AST/NoProfileFunctionAttr.h
+++ b/include/multiplier/AST/NoProfileFunctionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoProfileFunctionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoProfileFunctionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoRandomizeLayoutAttr.h b/include/multiplier/AST/NoRandomizeLayoutAttr.h
index e4ebdea6d..4736e19fd 100644
--- a/include/multiplier/AST/NoRandomizeLayoutAttr.h
+++ b/include/multiplier/AST/NoRandomizeLayoutAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoRandomizeLayoutAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoRandomizeLayoutAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoReturnAttr.h b/include/multiplier/AST/NoReturnAttr.h
index e778b9f97..979b3a5c6 100644
--- a/include/multiplier/AST/NoReturnAttr.h
+++ b/include/multiplier/AST/NoReturnAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoReturnAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoReturnAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoSanitizeAttr.h b/include/multiplier/AST/NoSanitizeAttr.h
index e787d62f8..69904d3d0 100644
--- a/include/multiplier/AST/NoSanitizeAttr.h
+++ b/include/multiplier/AST/NoSanitizeAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoSanitizeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoSanitizeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoSpeculativeLoadHardeningAttr.h b/include/multiplier/AST/NoSpeculativeLoadHardeningAttr.h
index 4dd9255bd..362964f90 100644
--- a/include/multiplier/AST/NoSpeculativeLoadHardeningAttr.h
+++ b/include/multiplier/AST/NoSpeculativeLoadHardeningAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoSpeculativeLoadHardeningAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoSpeculativeLoadHardeningAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoSplitStackAttr.h b/include/multiplier/AST/NoSplitStackAttr.h
index b8db5b423..e6498e3b9 100644
--- a/include/multiplier/AST/NoSplitStackAttr.h
+++ b/include/multiplier/AST/NoSplitStackAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoSplitStackAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoSplitStackAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoStackProtectorAttr.h b/include/multiplier/AST/NoStackProtectorAttr.h
index eccf19653..6d7a1a89d 100644
--- a/include/multiplier/AST/NoStackProtectorAttr.h
+++ b/include/multiplier/AST/NoStackProtectorAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class NoStackProtectorAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoStackProtectorAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoThreadSafetyAnalysisAttr.h b/include/multiplier/AST/NoThreadSafetyAnalysisAttr.h
index be4d5ba3a..ce685ce5c 100644
--- a/include/multiplier/AST/NoThreadSafetyAnalysisAttr.h
+++ b/include/multiplier/AST/NoThreadSafetyAnalysisAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoThreadSafetyAnalysisAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoThreadSafetyAnalysisAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoThrowAttr.h b/include/multiplier/AST/NoThrowAttr.h
index 6ee04f53b..29db50fa4 100644
--- a/include/multiplier/AST/NoThrowAttr.h
+++ b/include/multiplier/AST/NoThrowAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoThrowAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoThrowAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoUniqueAddressAttr.h b/include/multiplier/AST/NoUniqueAddressAttr.h
index 317da7fcc..665555ee5 100644
--- a/include/multiplier/AST/NoUniqueAddressAttr.h
+++ b/include/multiplier/AST/NoUniqueAddressAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoUniqueAddressAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoUniqueAddressAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NoUwtableAttr.h b/include/multiplier/AST/NoUwtableAttr.h
index 928d3a937..8ae45429d 100644
--- a/include/multiplier/AST/NoUwtableAttr.h
+++ b/include/multiplier/AST/NoUwtableAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NoUwtableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NoUwtableAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NonNullAttr.h b/include/multiplier/AST/NonNullAttr.h
index c3075a49d..8f38793e3 100644
--- a/include/multiplier/AST/NonNullAttr.h
+++ b/include/multiplier/AST/NonNullAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class InheritableParamAttr;
 class NonNullAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NonNullAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/NonTypeTemplateParmDecl.h b/include/multiplier/AST/NonTypeTemplateParmDecl.h
index 56417dc26..7ce8a99a0 100644
--- a/include/multiplier/AST/NonTypeTemplateParmDecl.h
+++ b/include/multiplier/AST/NonTypeTemplateParmDecl.h
@@ -23,11 +23,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NonTypeTemplateParmDecl : public DeclaratorDecl {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT NonTypeTemplateParmDecl : public DeclaratorDecl {
   static gap::generator<NonTypeTemplateParmDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<NonTypeTemplateParmDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<NonTypeTemplateParmDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<NonTypeTemplateParmDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::NON_TYPE_TEMPLATE_PARM;
   }
diff --git a/include/multiplier/AST/NotTailCalledAttr.h b/include/multiplier/AST/NotTailCalledAttr.h
index d15ba41e4..21ecea8f3 100644
--- a/include/multiplier/AST/NotTailCalledAttr.h
+++ b/include/multiplier/AST/NotTailCalledAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class NotTailCalledAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NotTailCalledAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/NullStmt.h b/include/multiplier/AST/NullStmt.h
index 85f1439c2..786849bed 100644
--- a/include/multiplier/AST/NullStmt.h
+++ b/include/multiplier/AST/NullStmt.h
@@ -18,11 +18,6 @@ class File;
 class NullStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT NullStmt : public Stmt {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT NullStmt : public Stmt {
   static gap::generator<NullStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<NullStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<NullStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<NullStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::NULL_STMT;
   }
diff --git a/include/multiplier/AST/OMPAllocateDecl.h b/include/multiplier/AST/OMPAllocateDecl.h
index d284d57bd..6fcdb851c 100644
--- a/include/multiplier/AST/OMPAllocateDecl.h
+++ b/include/multiplier/AST/OMPAllocateDecl.h
@@ -20,11 +20,6 @@ class OMPAllocateDecl;
 class OMPDeclarativeDirectiveDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPAllocateDecl : public OMPDeclarativeDirectiveDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPAllocateDecl : public OMPDeclarativeDirectiveDecl {
   static gap::generator<OMPAllocateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPAllocateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPAllocateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPAllocateDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OMP_ALLOCATE;
   }
diff --git a/include/multiplier/AST/OMPAllocateDeclAttr.h b/include/multiplier/AST/OMPAllocateDeclAttr.h
index fd1486a53..b287a4667 100644
--- a/include/multiplier/AST/OMPAllocateDeclAttr.h
+++ b/include/multiplier/AST/OMPAllocateDeclAttr.h
@@ -20,11 +20,6 @@ class File;
 class InheritableAttr;
 class OMPAllocateDeclAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPAllocateDeclAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OMPArraySectionExpr.h b/include/multiplier/AST/OMPArraySectionExpr.h
index d645592d1..0aca6d245 100644
--- a/include/multiplier/AST/OMPArraySectionExpr.h
+++ b/include/multiplier/AST/OMPArraySectionExpr.h
@@ -20,11 +20,6 @@ class OMPArraySectionExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPArraySectionExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT OMPArraySectionExpr : public Expr {
   static gap::generator<OMPArraySectionExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPArraySectionExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPArraySectionExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPArraySectionExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_ARRAY_SECTION_EXPR;
   }
diff --git a/include/multiplier/AST/OMPArrayShapingExpr.h b/include/multiplier/AST/OMPArrayShapingExpr.h
index 97908de6d..165609b77 100644
--- a/include/multiplier/AST/OMPArrayShapingExpr.h
+++ b/include/multiplier/AST/OMPArrayShapingExpr.h
@@ -20,11 +20,6 @@ class OMPArrayShapingExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPArrayShapingExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT OMPArrayShapingExpr : public Expr {
   static gap::generator<OMPArrayShapingExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPArrayShapingExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPArrayShapingExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPArrayShapingExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_ARRAY_SHAPING_EXPR;
   }
diff --git a/include/multiplier/AST/OMPAtomicDirective.h b/include/multiplier/AST/OMPAtomicDirective.h
index cf9963727..9236230a0 100644
--- a/include/multiplier/AST/OMPAtomicDirective.h
+++ b/include/multiplier/AST/OMPAtomicDirective.h
@@ -20,11 +20,6 @@ class OMPAtomicDirective;
 class OMPExecutableDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPAtomicDirective : public OMPExecutableDirective {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPAtomicDirective : public OMPExecutableDirective {
   static gap::generator<OMPAtomicDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPAtomicDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPAtomicDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPAtomicDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_ATOMIC_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPBarrierDirective.h b/include/multiplier/AST/OMPBarrierDirective.h
index 41eb1c936..ca811910a 100644
--- a/include/multiplier/AST/OMPBarrierDirective.h
+++ b/include/multiplier/AST/OMPBarrierDirective.h
@@ -19,11 +19,6 @@ class OMPBarrierDirective;
 class OMPExecutableDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPBarrierDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPBarrierDirective : public OMPExecutableDirective {
   static gap::generator<OMPBarrierDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPBarrierDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPBarrierDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPBarrierDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_BARRIER_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPCancelDirective.h b/include/multiplier/AST/OMPCancelDirective.h
index dc38c6936..5ff4decfd 100644
--- a/include/multiplier/AST/OMPCancelDirective.h
+++ b/include/multiplier/AST/OMPCancelDirective.h
@@ -19,11 +19,6 @@ class OMPCancelDirective;
 class OMPExecutableDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPCancelDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPCancelDirective : public OMPExecutableDirective {
   static gap::generator<OMPCancelDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPCancelDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPCancelDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPCancelDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_CANCEL_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPCancellationPointDirective.h b/include/multiplier/AST/OMPCancellationPointDirective.h
index c581eb504..0ba0b710e 100644
--- a/include/multiplier/AST/OMPCancellationPointDirective.h
+++ b/include/multiplier/AST/OMPCancellationPointDirective.h
@@ -19,11 +19,6 @@ class OMPCancellationPointDirective;
 class OMPExecutableDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPCancellationPointDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPCancellationPointDirective : public OMPExecutableDirective {
   static gap::generator<OMPCancellationPointDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPCancellationPointDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPCancellationPointDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPCancellationPointDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_CANCELLATION_POINT_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPCanonicalLoop.h b/include/multiplier/AST/OMPCanonicalLoop.h
index 3ef9f0b4a..1f74bdf60 100644
--- a/include/multiplier/AST/OMPCanonicalLoop.h
+++ b/include/multiplier/AST/OMPCanonicalLoop.h
@@ -20,11 +20,6 @@ class File;
 class OMPCanonicalLoop;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPCanonicalLoop : public Stmt {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPCanonicalLoop : public Stmt {
   static gap::generator<OMPCanonicalLoop> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPCanonicalLoop> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPCanonicalLoop, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPCanonicalLoop> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_CANONICAL_LOOP;
   }
diff --git a/include/multiplier/AST/OMPCaptureKindAttr.h b/include/multiplier/AST/OMPCaptureKindAttr.h
index 8e234cad5..6c4c09a18 100644
--- a/include/multiplier/AST/OMPCaptureKindAttr.h
+++ b/include/multiplier/AST/OMPCaptureKindAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class OMPCaptureKindAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPCaptureKindAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/OMPCaptureNoInitAttr.h b/include/multiplier/AST/OMPCaptureNoInitAttr.h
index f209c52cf..2278ad1c3 100644
--- a/include/multiplier/AST/OMPCaptureNoInitAttr.h
+++ b/include/multiplier/AST/OMPCaptureNoInitAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OMPCaptureNoInitAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPCaptureNoInitAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OMPCapturedExprDecl.h b/include/multiplier/AST/OMPCapturedExprDecl.h
index abca117b8..d88e14487 100644
--- a/include/multiplier/AST/OMPCapturedExprDecl.h
+++ b/include/multiplier/AST/OMPCapturedExprDecl.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class ValueDecl;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPCapturedExprDecl : public VarDecl {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT OMPCapturedExprDecl : public VarDecl {
   static gap::generator<OMPCapturedExprDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPCapturedExprDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPCapturedExprDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPCapturedExprDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OMP_CAPTURED_EXPR;
   }
diff --git a/include/multiplier/AST/OMPCriticalDirective.h b/include/multiplier/AST/OMPCriticalDirective.h
index b21d148e5..6cf8dabf6 100644
--- a/include/multiplier/AST/OMPCriticalDirective.h
+++ b/include/multiplier/AST/OMPCriticalDirective.h
@@ -19,11 +19,6 @@ class OMPCriticalDirective;
 class OMPExecutableDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPCriticalDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPCriticalDirective : public OMPExecutableDirective {
   static gap::generator<OMPCriticalDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPCriticalDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPCriticalDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPCriticalDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_CRITICAL_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPDeclarativeDirectiveDecl.h b/include/multiplier/AST/OMPDeclarativeDirectiveDecl.h
index 969ca763d..106e8825b 100644
--- a/include/multiplier/AST/OMPDeclarativeDirectiveDecl.h
+++ b/include/multiplier/AST/OMPDeclarativeDirectiveDecl.h
@@ -18,11 +18,6 @@ class File;
 class OMPDeclarativeDirectiveDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDeclarativeDirectiveDecl : public Decl {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT OMPDeclarativeDirectiveDecl : public Decl {
   static gap::generator<OMPDeclarativeDirectiveDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDeclarativeDirectiveDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDeclarativeDirectiveDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDeclarativeDirectiveDecl> in(const Compilation &tu);
   static gap::generator<OMPDeclarativeDirectiveDecl> containing(const Decl &decl);
   static gap::generator<OMPDeclarativeDirectiveDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/OMPDeclarativeDirectiveValueDecl.h b/include/multiplier/AST/OMPDeclarativeDirectiveValueDecl.h
index 0ef1e2002..b8a09c97a 100644
--- a/include/multiplier/AST/OMPDeclarativeDirectiveValueDecl.h
+++ b/include/multiplier/AST/OMPDeclarativeDirectiveValueDecl.h
@@ -20,11 +20,6 @@ class OMPDeclarativeDirectiveValueDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDeclarativeDirectiveValueDecl : public ValueDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT OMPDeclarativeDirectiveValueDecl : public ValueDecl {
   static gap::generator<OMPDeclarativeDirectiveValueDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDeclarativeDirectiveValueDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDeclarativeDirectiveValueDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDeclarativeDirectiveValueDecl> in(const Compilation &tu);
   static gap::generator<OMPDeclarativeDirectiveValueDecl> containing(const Decl &decl);
   static gap::generator<OMPDeclarativeDirectiveValueDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/OMPDeclareMapperDecl.h b/include/multiplier/AST/OMPDeclareMapperDecl.h
index b37fa545a..379809716 100644
--- a/include/multiplier/AST/OMPDeclareMapperDecl.h
+++ b/include/multiplier/AST/OMPDeclareMapperDecl.h
@@ -23,11 +23,6 @@ class OMPDeclareMapperDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDeclareMapperDecl : public OMPDeclarativeDirectiveValueDecl {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT OMPDeclareMapperDecl : public OMPDeclarativeDirectiveValueDecl {
   static gap::generator<OMPDeclareMapperDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDeclareMapperDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDeclareMapperDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDeclareMapperDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OMP_DECLARE_MAPPER;
   }
diff --git a/include/multiplier/AST/OMPDeclareReductionDecl.h b/include/multiplier/AST/OMPDeclareReductionDecl.h
index d1d143bcf..fe137c17c 100644
--- a/include/multiplier/AST/OMPDeclareReductionDecl.h
+++ b/include/multiplier/AST/OMPDeclareReductionDecl.h
@@ -23,11 +23,6 @@ class OMPDeclareReductionDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDeclareReductionDecl : public ValueDecl {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT OMPDeclareReductionDecl : public ValueDecl {
   static gap::generator<OMPDeclareReductionDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDeclareReductionDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDeclareReductionDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDeclareReductionDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OMP_DECLARE_REDUCTION;
   }
diff --git a/include/multiplier/AST/OMPDeclareSimdDeclAttr.h b/include/multiplier/AST/OMPDeclareSimdDeclAttr.h
index 5b7ba72d6..40b3bc099 100644
--- a/include/multiplier/AST/OMPDeclareSimdDeclAttr.h
+++ b/include/multiplier/AST/OMPDeclareSimdDeclAttr.h
@@ -19,11 +19,6 @@ class Expr;
 class File;
 class OMPDeclareSimdDeclAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDeclareSimdDeclAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/OMPDeclareTargetDeclAttr.h b/include/multiplier/AST/OMPDeclareTargetDeclAttr.h
index 0b7069abd..1dd240b54 100644
--- a/include/multiplier/AST/OMPDeclareTargetDeclAttr.h
+++ b/include/multiplier/AST/OMPDeclareTargetDeclAttr.h
@@ -21,11 +21,6 @@ class File;
 class InheritableAttr;
 class OMPDeclareTargetDeclAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDeclareTargetDeclAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OMPDeclareVariantAttr.h b/include/multiplier/AST/OMPDeclareVariantAttr.h
index edd80b374..f9fd2ebf2 100644
--- a/include/multiplier/AST/OMPDeclareVariantAttr.h
+++ b/include/multiplier/AST/OMPDeclareVariantAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class OMPDeclareVariantAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDeclareVariantAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OMPDepobjDirective.h b/include/multiplier/AST/OMPDepobjDirective.h
index 12b99dbdb..ba30ca8e0 100644
--- a/include/multiplier/AST/OMPDepobjDirective.h
+++ b/include/multiplier/AST/OMPDepobjDirective.h
@@ -19,11 +19,6 @@ class OMPDepobjDirective;
 class OMPExecutableDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDepobjDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPDepobjDirective : public OMPExecutableDirective {
   static gap::generator<OMPDepobjDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDepobjDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDepobjDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDepobjDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_DEPOBJ_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPDispatchDirective.h b/include/multiplier/AST/OMPDispatchDirective.h
index 874bb738d..3d8771c8d 100644
--- a/include/multiplier/AST/OMPDispatchDirective.h
+++ b/include/multiplier/AST/OMPDispatchDirective.h
@@ -19,11 +19,6 @@ class OMPDispatchDirective;
 class OMPExecutableDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDispatchDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPDispatchDirective : public OMPExecutableDirective {
   static gap::generator<OMPDispatchDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDispatchDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDispatchDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDispatchDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_DISPATCH_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPDistributeDirective.h b/include/multiplier/AST/OMPDistributeDirective.h
index 4f3b80535..53f3ac30f 100644
--- a/include/multiplier/AST/OMPDistributeDirective.h
+++ b/include/multiplier/AST/OMPDistributeDirective.h
@@ -21,11 +21,6 @@ class OMPLoopBasedDirective;
 class OMPLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDistributeDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPDistributeDirective : public OMPLoopDirective {
   static gap::generator<OMPDistributeDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDistributeDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDistributeDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDistributeDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_DISTRIBUTE_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPDistributeParallelForDirective.h b/include/multiplier/AST/OMPDistributeParallelForDirective.h
index 64fe91b65..0326fa2da 100644
--- a/include/multiplier/AST/OMPDistributeParallelForDirective.h
+++ b/include/multiplier/AST/OMPDistributeParallelForDirective.h
@@ -22,11 +22,6 @@ class OMPLoopBasedDirective;
 class OMPLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDistributeParallelForDirective : public OMPLoopDirective {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT OMPDistributeParallelForDirective : public OMPLoopDirective {
   static gap::generator<OMPDistributeParallelForDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDistributeParallelForDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDistributeParallelForDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDistributeParallelForDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPDistributeParallelForSimdDirective.h b/include/multiplier/AST/OMPDistributeParallelForSimdDirective.h
index afb0ea634..25d11901e 100644
--- a/include/multiplier/AST/OMPDistributeParallelForSimdDirective.h
+++ b/include/multiplier/AST/OMPDistributeParallelForSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopBasedDirective;
 class OMPLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDistributeParallelForSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPDistributeParallelForSimdDirective : public OMPLoopDirective
   static gap::generator<OMPDistributeParallelForSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDistributeParallelForSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDistributeParallelForSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDistributeParallelForSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPDistributeSimdDirective.h b/include/multiplier/AST/OMPDistributeSimdDirective.h
index bb04ece0f..5f91e084d 100644
--- a/include/multiplier/AST/OMPDistributeSimdDirective.h
+++ b/include/multiplier/AST/OMPDistributeSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopBasedDirective;
 class OMPLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPDistributeSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPDistributeSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPDistributeSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPDistributeSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPDistributeSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPDistributeSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_DISTRIBUTE_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPErrorDirective.h b/include/multiplier/AST/OMPErrorDirective.h
index ba66dcbb5..a023ba5de 100644
--- a/include/multiplier/AST/OMPErrorDirective.h
+++ b/include/multiplier/AST/OMPErrorDirective.h
@@ -19,11 +19,6 @@ class OMPErrorDirective;
 class OMPExecutableDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPErrorDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPErrorDirective : public OMPExecutableDirective {
   static gap::generator<OMPErrorDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPErrorDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPErrorDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPErrorDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_ERROR_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPExecutableDirective.h b/include/multiplier/AST/OMPExecutableDirective.h
index 3f7fd7c8c..89ffac270 100644
--- a/include/multiplier/AST/OMPExecutableDirective.h
+++ b/include/multiplier/AST/OMPExecutableDirective.h
@@ -19,11 +19,6 @@ class File;
 class OMPExecutableDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPExecutableDirective : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT OMPExecutableDirective : public Stmt {
   static gap::generator<OMPExecutableDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPExecutableDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPExecutableDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPExecutableDirective> in(const Compilation &tu);
   static gap::generator<OMPExecutableDirective> containing(const Decl &decl);
   static gap::generator<OMPExecutableDirective> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/OMPFlushDirective.h b/include/multiplier/AST/OMPFlushDirective.h
index 2e130def9..bee386b3b 100644
--- a/include/multiplier/AST/OMPFlushDirective.h
+++ b/include/multiplier/AST/OMPFlushDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPFlushDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPFlushDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPFlushDirective : public OMPExecutableDirective {
   static gap::generator<OMPFlushDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPFlushDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPFlushDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPFlushDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_FLUSH_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPForDirective.h b/include/multiplier/AST/OMPForDirective.h
index 8dbcd0213..cb609a254 100644
--- a/include/multiplier/AST/OMPForDirective.h
+++ b/include/multiplier/AST/OMPForDirective.h
@@ -22,11 +22,6 @@ class OMPLoopBasedDirective;
 class OMPLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPForDirective : public OMPLoopDirective {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT OMPForDirective : public OMPLoopDirective {
   static gap::generator<OMPForDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPForDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPForDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPForDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_FOR_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPForSimdDirective.h b/include/multiplier/AST/OMPForSimdDirective.h
index 064b738e8..dfd50ec15 100644
--- a/include/multiplier/AST/OMPForSimdDirective.h
+++ b/include/multiplier/AST/OMPForSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopBasedDirective;
 class OMPLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPForSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPForSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPForSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPForSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPForSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPForSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_FOR_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPGenericLoopDirective.h b/include/multiplier/AST/OMPGenericLoopDirective.h
index 8cf0b5987..eef9e854a 100644
--- a/include/multiplier/AST/OMPGenericLoopDirective.h
+++ b/include/multiplier/AST/OMPGenericLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopBasedDirective;
 class OMPLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPGenericLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPGenericLoopDirective : public OMPLoopDirective {
   static gap::generator<OMPGenericLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPGenericLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPGenericLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPGenericLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_GENERIC_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPInteropDirective.h b/include/multiplier/AST/OMPInteropDirective.h
index a02a5bdbd..e3037d24d 100644
--- a/include/multiplier/AST/OMPInteropDirective.h
+++ b/include/multiplier/AST/OMPInteropDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPInteropDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPInteropDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPInteropDirective : public OMPExecutableDirective {
   static gap::generator<OMPInteropDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPInteropDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPInteropDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPInteropDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_INTEROP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPIteratorExpr.h b/include/multiplier/AST/OMPIteratorExpr.h
index b744c647e..0a9988896 100644
--- a/include/multiplier/AST/OMPIteratorExpr.h
+++ b/include/multiplier/AST/OMPIteratorExpr.h
@@ -20,11 +20,6 @@ class OMPIteratorExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPIteratorExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT OMPIteratorExpr : public Expr {
   static gap::generator<OMPIteratorExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPIteratorExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPIteratorExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPIteratorExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_ITERATOR_EXPR;
   }
diff --git a/include/multiplier/AST/OMPLoopBasedDirective.h b/include/multiplier/AST/OMPLoopBasedDirective.h
index 836d77376..3e937e513 100644
--- a/include/multiplier/AST/OMPLoopBasedDirective.h
+++ b/include/multiplier/AST/OMPLoopBasedDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPLoopBasedDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPLoopBasedDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPLoopBasedDirective : public OMPExecutableDirective {
   static gap::generator<OMPLoopBasedDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPLoopBasedDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPLoopBasedDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPLoopBasedDirective> in(const Compilation &tu);
   static gap::generator<OMPLoopBasedDirective> containing(const Decl &decl);
   static gap::generator<OMPLoopBasedDirective> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/OMPLoopDirective.h b/include/multiplier/AST/OMPLoopDirective.h
index a183ed309..53b603ccb 100644
--- a/include/multiplier/AST/OMPLoopDirective.h
+++ b/include/multiplier/AST/OMPLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopBasedDirective;
 class OMPLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPLoopDirective : public OMPLoopBasedDirective {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT OMPLoopDirective : public OMPLoopBasedDirective {
   static gap::generator<OMPLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPLoopDirective> in(const Compilation &tu);
   static gap::generator<OMPLoopDirective> containing(const Decl &decl);
   static gap::generator<OMPLoopDirective> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/OMPLoopTransformationDirective.h b/include/multiplier/AST/OMPLoopTransformationDirective.h
index 5a24e04cd..2efb7dc0d 100644
--- a/include/multiplier/AST/OMPLoopTransformationDirective.h
+++ b/include/multiplier/AST/OMPLoopTransformationDirective.h
@@ -20,11 +20,6 @@ class OMPLoopBasedDirective;
 class OMPLoopTransformationDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPLoopTransformationDirective : public OMPLoopBasedDirective {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT OMPLoopTransformationDirective : public OMPLoopBasedDirective {
   static gap::generator<OMPLoopTransformationDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPLoopTransformationDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPLoopTransformationDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPLoopTransformationDirective> in(const Compilation &tu);
   static gap::generator<OMPLoopTransformationDirective> containing(const Decl &decl);
   static gap::generator<OMPLoopTransformationDirective> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/OMPMaskedDirective.h b/include/multiplier/AST/OMPMaskedDirective.h
index 797ada820..38873b6ee 100644
--- a/include/multiplier/AST/OMPMaskedDirective.h
+++ b/include/multiplier/AST/OMPMaskedDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPMaskedDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPMaskedDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPMaskedDirective : public OMPExecutableDirective {
   static gap::generator<OMPMaskedDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPMaskedDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPMaskedDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPMaskedDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_MASKED_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPMaskedTaskLoopDirective.h b/include/multiplier/AST/OMPMaskedTaskLoopDirective.h
index c46e6b199..13dee62c7 100644
--- a/include/multiplier/AST/OMPMaskedTaskLoopDirective.h
+++ b/include/multiplier/AST/OMPMaskedTaskLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPMaskedTaskLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPMaskedTaskLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPMaskedTaskLoopDirective : public OMPLoopDirective {
   static gap::generator<OMPMaskedTaskLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPMaskedTaskLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPMaskedTaskLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPMaskedTaskLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_MASKED_TASK_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPMaskedTaskLoopSimdDirective.h b/include/multiplier/AST/OMPMaskedTaskLoopSimdDirective.h
index ae40a0806..b1408d438 100644
--- a/include/multiplier/AST/OMPMaskedTaskLoopSimdDirective.h
+++ b/include/multiplier/AST/OMPMaskedTaskLoopSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPMaskedTaskLoopSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPMaskedTaskLoopSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPMaskedTaskLoopSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPMaskedTaskLoopSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPMaskedTaskLoopSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPMaskedTaskLoopSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPMaskedTaskLoopSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_MASKED_TASK_LOOP_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPMasterDirective.h b/include/multiplier/AST/OMPMasterDirective.h
index 776037547..be3d73f60 100644
--- a/include/multiplier/AST/OMPMasterDirective.h
+++ b/include/multiplier/AST/OMPMasterDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPMasterDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPMasterDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPMasterDirective : public OMPExecutableDirective {
   static gap::generator<OMPMasterDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPMasterDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPMasterDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPMasterDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_MASTER_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPMasterTaskLoopDirective.h b/include/multiplier/AST/OMPMasterTaskLoopDirective.h
index 46eecf948..2f6a0a1f6 100644
--- a/include/multiplier/AST/OMPMasterTaskLoopDirective.h
+++ b/include/multiplier/AST/OMPMasterTaskLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPMasterTaskLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPMasterTaskLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPMasterTaskLoopDirective : public OMPLoopDirective {
   static gap::generator<OMPMasterTaskLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPMasterTaskLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPMasterTaskLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPMasterTaskLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_MASTER_TASK_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPMasterTaskLoopSimdDirective.h b/include/multiplier/AST/OMPMasterTaskLoopSimdDirective.h
index 2113db626..9a5f7b829 100644
--- a/include/multiplier/AST/OMPMasterTaskLoopSimdDirective.h
+++ b/include/multiplier/AST/OMPMasterTaskLoopSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPMasterTaskLoopSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPMasterTaskLoopSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPMasterTaskLoopSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPMasterTaskLoopSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPMasterTaskLoopSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPMasterTaskLoopSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPMasterTaskLoopSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_MASTER_TASK_LOOP_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPMetaDirective.h b/include/multiplier/AST/OMPMetaDirective.h
index 76cb7de56..d7a2cf205 100644
--- a/include/multiplier/AST/OMPMetaDirective.h
+++ b/include/multiplier/AST/OMPMetaDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPMetaDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPMetaDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPMetaDirective : public OMPExecutableDirective {
   static gap::generator<OMPMetaDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPMetaDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPMetaDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPMetaDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_META_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPOrderedDirective.h b/include/multiplier/AST/OMPOrderedDirective.h
index 0933c8331..95bb265a3 100644
--- a/include/multiplier/AST/OMPOrderedDirective.h
+++ b/include/multiplier/AST/OMPOrderedDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPOrderedDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPOrderedDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPOrderedDirective : public OMPExecutableDirective {
   static gap::generator<OMPOrderedDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPOrderedDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPOrderedDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPOrderedDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_ORDERED_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelDirective.h b/include/multiplier/AST/OMPParallelDirective.h
index 9a7d2c92d..3fdbaaf13 100644
--- a/include/multiplier/AST/OMPParallelDirective.h
+++ b/include/multiplier/AST/OMPParallelDirective.h
@@ -20,11 +20,6 @@ class OMPExecutableDirective;
 class OMPParallelDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelDirective : public OMPExecutableDirective {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPParallelDirective : public OMPExecutableDirective {
   static gap::generator<OMPParallelDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelForDirective.h b/include/multiplier/AST/OMPParallelForDirective.h
index 5b0f554d5..65638b6a1 100644
--- a/include/multiplier/AST/OMPParallelForDirective.h
+++ b/include/multiplier/AST/OMPParallelForDirective.h
@@ -22,11 +22,6 @@ class OMPLoopDirective;
 class OMPParallelForDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelForDirective : public OMPLoopDirective {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT OMPParallelForDirective : public OMPLoopDirective {
   static gap::generator<OMPParallelForDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelForDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelForDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelForDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_FOR_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelForSimdDirective.h b/include/multiplier/AST/OMPParallelForSimdDirective.h
index c3cb1acae..ec5648756 100644
--- a/include/multiplier/AST/OMPParallelForSimdDirective.h
+++ b/include/multiplier/AST/OMPParallelForSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPParallelForSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelForSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPParallelForSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPParallelForSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelForSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelForSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelForSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelGenericLoopDirective.h b/include/multiplier/AST/OMPParallelGenericLoopDirective.h
index 7f04178ef..7b3354814 100644
--- a/include/multiplier/AST/OMPParallelGenericLoopDirective.h
+++ b/include/multiplier/AST/OMPParallelGenericLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPParallelGenericLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelGenericLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPParallelGenericLoopDirective : public OMPLoopDirective {
   static gap::generator<OMPParallelGenericLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelGenericLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelGenericLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelGenericLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelMaskedDirective.h b/include/multiplier/AST/OMPParallelMaskedDirective.h
index 6eec56d75..7d726eed6 100644
--- a/include/multiplier/AST/OMPParallelMaskedDirective.h
+++ b/include/multiplier/AST/OMPParallelMaskedDirective.h
@@ -20,11 +20,6 @@ class OMPExecutableDirective;
 class OMPParallelMaskedDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelMaskedDirective : public OMPExecutableDirective {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPParallelMaskedDirective : public OMPExecutableDirective {
   static gap::generator<OMPParallelMaskedDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelMaskedDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelMaskedDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelMaskedDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_MASKED_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelMaskedTaskLoopDirective.h b/include/multiplier/AST/OMPParallelMaskedTaskLoopDirective.h
index e2351e93f..8779dbaeb 100644
--- a/include/multiplier/AST/OMPParallelMaskedTaskLoopDirective.h
+++ b/include/multiplier/AST/OMPParallelMaskedTaskLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPParallelMaskedTaskLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelMaskedTaskLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPParallelMaskedTaskLoopDirective : public OMPLoopDirective {
   static gap::generator<OMPParallelMaskedTaskLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelMaskedTaskLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelMaskedTaskLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelMaskedTaskLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_MASKED_TASK_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelMaskedTaskLoopSimdDirective.h b/include/multiplier/AST/OMPParallelMaskedTaskLoopSimdDirective.h
index 55de9d690..cba462e65 100644
--- a/include/multiplier/AST/OMPParallelMaskedTaskLoopSimdDirective.h
+++ b/include/multiplier/AST/OMPParallelMaskedTaskLoopSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPParallelMaskedTaskLoopSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelMaskedTaskLoopSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPParallelMaskedTaskLoopSimdDirective : public OMPLoopDirective
   static gap::generator<OMPParallelMaskedTaskLoopSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelMaskedTaskLoopSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelMaskedTaskLoopSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelMaskedTaskLoopSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_MASKED_TASK_LOOP_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelMasterDirective.h b/include/multiplier/AST/OMPParallelMasterDirective.h
index 47468857a..951fb80b3 100644
--- a/include/multiplier/AST/OMPParallelMasterDirective.h
+++ b/include/multiplier/AST/OMPParallelMasterDirective.h
@@ -20,11 +20,6 @@ class OMPExecutableDirective;
 class OMPParallelMasterDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelMasterDirective : public OMPExecutableDirective {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPParallelMasterDirective : public OMPExecutableDirective {
   static gap::generator<OMPParallelMasterDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelMasterDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelMasterDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelMasterDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_MASTER_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelMasterTaskLoopDirective.h b/include/multiplier/AST/OMPParallelMasterTaskLoopDirective.h
index 3f4231dab..050af48f9 100644
--- a/include/multiplier/AST/OMPParallelMasterTaskLoopDirective.h
+++ b/include/multiplier/AST/OMPParallelMasterTaskLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPParallelMasterTaskLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelMasterTaskLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPParallelMasterTaskLoopDirective : public OMPLoopDirective {
   static gap::generator<OMPParallelMasterTaskLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelMasterTaskLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelMasterTaskLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelMasterTaskLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_MASTER_TASK_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelMasterTaskLoopSimdDirective.h b/include/multiplier/AST/OMPParallelMasterTaskLoopSimdDirective.h
index 7102682ce..3b7eb701e 100644
--- a/include/multiplier/AST/OMPParallelMasterTaskLoopSimdDirective.h
+++ b/include/multiplier/AST/OMPParallelMasterTaskLoopSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPParallelMasterTaskLoopSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelMasterTaskLoopSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPParallelMasterTaskLoopSimdDirective : public OMPLoopDirective
   static gap::generator<OMPParallelMasterTaskLoopSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelMasterTaskLoopSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelMasterTaskLoopSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelMasterTaskLoopSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_MASTER_TASK_LOOP_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPParallelSectionsDirective.h b/include/multiplier/AST/OMPParallelSectionsDirective.h
index a94ddf399..553e93021 100644
--- a/include/multiplier/AST/OMPParallelSectionsDirective.h
+++ b/include/multiplier/AST/OMPParallelSectionsDirective.h
@@ -20,11 +20,6 @@ class OMPExecutableDirective;
 class OMPParallelSectionsDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPParallelSectionsDirective : public OMPExecutableDirective {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPParallelSectionsDirective : public OMPExecutableDirective {
   static gap::generator<OMPParallelSectionsDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPParallelSectionsDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPParallelSectionsDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPParallelSectionsDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_PARALLEL_SECTIONS_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPReferencedVarAttr.h b/include/multiplier/AST/OMPReferencedVarAttr.h
index f1a1db368..9012e6d3a 100644
--- a/include/multiplier/AST/OMPReferencedVarAttr.h
+++ b/include/multiplier/AST/OMPReferencedVarAttr.h
@@ -18,11 +18,6 @@ class Expr;
 class File;
 class OMPReferencedVarAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPReferencedVarAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/OMPRequiresDecl.h b/include/multiplier/AST/OMPRequiresDecl.h
index 3525c0a3c..e2d48d5c9 100644
--- a/include/multiplier/AST/OMPRequiresDecl.h
+++ b/include/multiplier/AST/OMPRequiresDecl.h
@@ -19,11 +19,6 @@ class OMPDeclarativeDirectiveDecl;
 class OMPRequiresDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPRequiresDecl : public OMPDeclarativeDirectiveDecl {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPRequiresDecl : public OMPDeclarativeDirectiveDecl {
   static gap::generator<OMPRequiresDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPRequiresDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPRequiresDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPRequiresDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OMP_REQUIRES;
   }
diff --git a/include/multiplier/AST/OMPScanDirective.h b/include/multiplier/AST/OMPScanDirective.h
index 9287c775b..984a265dc 100644
--- a/include/multiplier/AST/OMPScanDirective.h
+++ b/include/multiplier/AST/OMPScanDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPScanDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPScanDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPScanDirective : public OMPExecutableDirective {
   static gap::generator<OMPScanDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPScanDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPScanDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPScanDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_SCAN_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPScopeDirective.h b/include/multiplier/AST/OMPScopeDirective.h
index b5522ae6b..e467f378d 100644
--- a/include/multiplier/AST/OMPScopeDirective.h
+++ b/include/multiplier/AST/OMPScopeDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPScopeDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPScopeDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPScopeDirective : public OMPExecutableDirective {
   static gap::generator<OMPScopeDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPScopeDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPScopeDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPScopeDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_SCOPE_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPSectionDirective.h b/include/multiplier/AST/OMPSectionDirective.h
index 9339ca64a..1000f7963 100644
--- a/include/multiplier/AST/OMPSectionDirective.h
+++ b/include/multiplier/AST/OMPSectionDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPSectionDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPSectionDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPSectionDirective : public OMPExecutableDirective {
   static gap::generator<OMPSectionDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPSectionDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPSectionDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPSectionDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_SECTION_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPSectionsDirective.h b/include/multiplier/AST/OMPSectionsDirective.h
index 4cfe81cba..6f751f3dc 100644
--- a/include/multiplier/AST/OMPSectionsDirective.h
+++ b/include/multiplier/AST/OMPSectionsDirective.h
@@ -20,11 +20,6 @@ class OMPExecutableDirective;
 class OMPSectionsDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPSectionsDirective : public OMPExecutableDirective {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPSectionsDirective : public OMPExecutableDirective {
   static gap::generator<OMPSectionsDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPSectionsDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPSectionsDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPSectionsDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_SECTIONS_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPSimdDirective.h b/include/multiplier/AST/OMPSimdDirective.h
index 499cbdb84..96e508d41 100644
--- a/include/multiplier/AST/OMPSimdDirective.h
+++ b/include/multiplier/AST/OMPSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPSingleDirective.h b/include/multiplier/AST/OMPSingleDirective.h
index e53af5eae..46f8f8599 100644
--- a/include/multiplier/AST/OMPSingleDirective.h
+++ b/include/multiplier/AST/OMPSingleDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPSingleDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPSingleDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPSingleDirective : public OMPExecutableDirective {
   static gap::generator<OMPSingleDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPSingleDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPSingleDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPSingleDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_SINGLE_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetDataDirective.h b/include/multiplier/AST/OMPTargetDataDirective.h
index 4c33a14d5..3a81566d0 100644
--- a/include/multiplier/AST/OMPTargetDataDirective.h
+++ b/include/multiplier/AST/OMPTargetDataDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTargetDataDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetDataDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTargetDataDirective : public OMPExecutableDirective {
   static gap::generator<OMPTargetDataDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetDataDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetDataDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetDataDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_DATA_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetDirective.h b/include/multiplier/AST/OMPTargetDirective.h
index fa4d03834..bf795628f 100644
--- a/include/multiplier/AST/OMPTargetDirective.h
+++ b/include/multiplier/AST/OMPTargetDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTargetDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTargetDirective : public OMPExecutableDirective {
   static gap::generator<OMPTargetDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetEnterDataDirective.h b/include/multiplier/AST/OMPTargetEnterDataDirective.h
index a90dc7637..6869c485d 100644
--- a/include/multiplier/AST/OMPTargetEnterDataDirective.h
+++ b/include/multiplier/AST/OMPTargetEnterDataDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTargetEnterDataDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetEnterDataDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTargetEnterDataDirective : public OMPExecutableDirective {
   static gap::generator<OMPTargetEnterDataDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetEnterDataDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetEnterDataDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetEnterDataDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_ENTER_DATA_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetExitDataDirective.h b/include/multiplier/AST/OMPTargetExitDataDirective.h
index bc5cd2cc3..f7ec7b9e6 100644
--- a/include/multiplier/AST/OMPTargetExitDataDirective.h
+++ b/include/multiplier/AST/OMPTargetExitDataDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTargetExitDataDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetExitDataDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTargetExitDataDirective : public OMPExecutableDirective {
   static gap::generator<OMPTargetExitDataDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetExitDataDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetExitDataDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetExitDataDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_EXIT_DATA_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetParallelDirective.h b/include/multiplier/AST/OMPTargetParallelDirective.h
index a6aeacc6d..1826973f4 100644
--- a/include/multiplier/AST/OMPTargetParallelDirective.h
+++ b/include/multiplier/AST/OMPTargetParallelDirective.h
@@ -20,11 +20,6 @@ class OMPExecutableDirective;
 class OMPTargetParallelDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetParallelDirective : public OMPExecutableDirective {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPTargetParallelDirective : public OMPExecutableDirective {
   static gap::generator<OMPTargetParallelDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetParallelDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetParallelDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetParallelDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_PARALLEL_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetParallelForDirective.h b/include/multiplier/AST/OMPTargetParallelForDirective.h
index 1bd1a7cb9..65a9e7322 100644
--- a/include/multiplier/AST/OMPTargetParallelForDirective.h
+++ b/include/multiplier/AST/OMPTargetParallelForDirective.h
@@ -22,11 +22,6 @@ class OMPLoopDirective;
 class OMPTargetParallelForDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetParallelForDirective : public OMPLoopDirective {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT OMPTargetParallelForDirective : public OMPLoopDirective {
   static gap::generator<OMPTargetParallelForDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetParallelForDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetParallelForDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetParallelForDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_PARALLEL_FOR_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetParallelForSimdDirective.h b/include/multiplier/AST/OMPTargetParallelForSimdDirective.h
index 2547654b7..bbdaaec48 100644
--- a/include/multiplier/AST/OMPTargetParallelForSimdDirective.h
+++ b/include/multiplier/AST/OMPTargetParallelForSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTargetParallelForSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetParallelForSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTargetParallelForSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPTargetParallelForSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetParallelForSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetParallelForSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetParallelForSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetParallelGenericLoopDirective.h b/include/multiplier/AST/OMPTargetParallelGenericLoopDirective.h
index a90b7dc07..6cfa4429d 100644
--- a/include/multiplier/AST/OMPTargetParallelGenericLoopDirective.h
+++ b/include/multiplier/AST/OMPTargetParallelGenericLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTargetParallelGenericLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetParallelGenericLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTargetParallelGenericLoopDirective : public OMPLoopDirective
   static gap::generator<OMPTargetParallelGenericLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetParallelGenericLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetParallelGenericLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetParallelGenericLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetSimdDirective.h b/include/multiplier/AST/OMPTargetSimdDirective.h
index 8e7a61b05..f6802b331 100644
--- a/include/multiplier/AST/OMPTargetSimdDirective.h
+++ b/include/multiplier/AST/OMPTargetSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTargetSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTargetSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPTargetSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetTeamsDirective.h b/include/multiplier/AST/OMPTargetTeamsDirective.h
index 1d2f2b73a..ef74a092a 100644
--- a/include/multiplier/AST/OMPTargetTeamsDirective.h
+++ b/include/multiplier/AST/OMPTargetTeamsDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTargetTeamsDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetTeamsDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTargetTeamsDirective : public OMPExecutableDirective {
   static gap::generator<OMPTargetTeamsDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetTeamsDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetTeamsDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetTeamsDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_TEAMS_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetTeamsDistributeDirective.h b/include/multiplier/AST/OMPTargetTeamsDistributeDirective.h
index ac853c8f0..1b9eac554 100644
--- a/include/multiplier/AST/OMPTargetTeamsDistributeDirective.h
+++ b/include/multiplier/AST/OMPTargetTeamsDistributeDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTargetTeamsDistributeDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetTeamsDistributeDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTargetTeamsDistributeDirective : public OMPLoopDirective {
   static gap::generator<OMPTargetTeamsDistributeDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetTeamsDistributeDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetTeamsDistributeDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetTeamsDistributeDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetTeamsDistributeParallelForDirective.h b/include/multiplier/AST/OMPTargetTeamsDistributeParallelForDirective.h
index 930f3bc78..c504b4785 100644
--- a/include/multiplier/AST/OMPTargetTeamsDistributeParallelForDirective.h
+++ b/include/multiplier/AST/OMPTargetTeamsDistributeParallelForDirective.h
@@ -22,11 +22,6 @@ class OMPLoopDirective;
 class OMPTargetTeamsDistributeParallelForDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetTeamsDistributeParallelForDirective : public OMPLoopDirective {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT OMPTargetTeamsDistributeParallelForDirective : public OMPLoopDir
   static gap::generator<OMPTargetTeamsDistributeParallelForDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetTeamsDistributeParallelForDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetTeamsDistributeParallelForDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetTeamsDistributeParallelForDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetTeamsDistributeParallelForSimdDirective.h b/include/multiplier/AST/OMPTargetTeamsDistributeParallelForSimdDirective.h
index bf42c810f..3d3f325c5 100644
--- a/include/multiplier/AST/OMPTargetTeamsDistributeParallelForSimdDirective.h
+++ b/include/multiplier/AST/OMPTargetTeamsDistributeParallelForSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTargetTeamsDistributeParallelForSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetTeamsDistributeParallelForSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTargetTeamsDistributeParallelForSimdDirective : public OMPLoo
   static gap::generator<OMPTargetTeamsDistributeParallelForSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetTeamsDistributeParallelForSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetTeamsDistributeParallelForSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetTeamsDistributeParallelForSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetTeamsDistributeSimdDirective.h b/include/multiplier/AST/OMPTargetTeamsDistributeSimdDirective.h
index a6cc48a4c..235ae7e1f 100644
--- a/include/multiplier/AST/OMPTargetTeamsDistributeSimdDirective.h
+++ b/include/multiplier/AST/OMPTargetTeamsDistributeSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTargetTeamsDistributeSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetTeamsDistributeSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTargetTeamsDistributeSimdDirective : public OMPLoopDirective
   static gap::generator<OMPTargetTeamsDistributeSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetTeamsDistributeSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetTeamsDistributeSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetTeamsDistributeSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetTeamsGenericLoopDirective.h b/include/multiplier/AST/OMPTargetTeamsGenericLoopDirective.h
index b69fb6d38..2ee970225 100644
--- a/include/multiplier/AST/OMPTargetTeamsGenericLoopDirective.h
+++ b/include/multiplier/AST/OMPTargetTeamsGenericLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTargetTeamsGenericLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetTeamsGenericLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTargetTeamsGenericLoopDirective : public OMPLoopDirective {
   static gap::generator<OMPTargetTeamsGenericLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetTeamsGenericLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetTeamsGenericLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetTeamsGenericLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTargetUpdateDirective.h b/include/multiplier/AST/OMPTargetUpdateDirective.h
index 852b7f573..bef3ce061 100644
--- a/include/multiplier/AST/OMPTargetUpdateDirective.h
+++ b/include/multiplier/AST/OMPTargetUpdateDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTargetUpdateDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTargetUpdateDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTargetUpdateDirective : public OMPExecutableDirective {
   static gap::generator<OMPTargetUpdateDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTargetUpdateDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTargetUpdateDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTargetUpdateDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TARGET_UPDATE_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTaskDirective.h b/include/multiplier/AST/OMPTaskDirective.h
index e6a897eb4..3befb2677 100644
--- a/include/multiplier/AST/OMPTaskDirective.h
+++ b/include/multiplier/AST/OMPTaskDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTaskDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTaskDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTaskDirective : public OMPExecutableDirective {
   static gap::generator<OMPTaskDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTaskDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTaskDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTaskDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TASK_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTaskLoopDirective.h b/include/multiplier/AST/OMPTaskLoopDirective.h
index fa4b15839..c52bb83f2 100644
--- a/include/multiplier/AST/OMPTaskLoopDirective.h
+++ b/include/multiplier/AST/OMPTaskLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTaskLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTaskLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTaskLoopDirective : public OMPLoopDirective {
   static gap::generator<OMPTaskLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTaskLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTaskLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTaskLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TASK_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTaskLoopSimdDirective.h b/include/multiplier/AST/OMPTaskLoopSimdDirective.h
index 54f581b3a..2e5c4945c 100644
--- a/include/multiplier/AST/OMPTaskLoopSimdDirective.h
+++ b/include/multiplier/AST/OMPTaskLoopSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTaskLoopSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTaskLoopSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTaskLoopSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPTaskLoopSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTaskLoopSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTaskLoopSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTaskLoopSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TASK_LOOP_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTaskgroupDirective.h b/include/multiplier/AST/OMPTaskgroupDirective.h
index ed29bb940..c2d816cf2 100644
--- a/include/multiplier/AST/OMPTaskgroupDirective.h
+++ b/include/multiplier/AST/OMPTaskgroupDirective.h
@@ -20,11 +20,6 @@ class OMPExecutableDirective;
 class OMPTaskgroupDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTaskgroupDirective : public OMPExecutableDirective {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPTaskgroupDirective : public OMPExecutableDirective {
   static gap::generator<OMPTaskgroupDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTaskgroupDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTaskgroupDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTaskgroupDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TASKGROUP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTaskwaitDirective.h b/include/multiplier/AST/OMPTaskwaitDirective.h
index b7fe598c5..cc9764cc8 100644
--- a/include/multiplier/AST/OMPTaskwaitDirective.h
+++ b/include/multiplier/AST/OMPTaskwaitDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTaskwaitDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTaskwaitDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTaskwaitDirective : public OMPExecutableDirective {
   static gap::generator<OMPTaskwaitDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTaskwaitDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTaskwaitDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTaskwaitDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TASKWAIT_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTaskyieldDirective.h b/include/multiplier/AST/OMPTaskyieldDirective.h
index e13be3358..81182b78e 100644
--- a/include/multiplier/AST/OMPTaskyieldDirective.h
+++ b/include/multiplier/AST/OMPTaskyieldDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTaskyieldDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTaskyieldDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTaskyieldDirective : public OMPExecutableDirective {
   static gap::generator<OMPTaskyieldDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTaskyieldDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTaskyieldDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTaskyieldDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TASKYIELD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTeamsDirective.h b/include/multiplier/AST/OMPTeamsDirective.h
index 4538e7db8..711b7bad7 100644
--- a/include/multiplier/AST/OMPTeamsDirective.h
+++ b/include/multiplier/AST/OMPTeamsDirective.h
@@ -19,11 +19,6 @@ class OMPExecutableDirective;
 class OMPTeamsDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTeamsDirective : public OMPExecutableDirective {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT OMPTeamsDirective : public OMPExecutableDirective {
   static gap::generator<OMPTeamsDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTeamsDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTeamsDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTeamsDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TEAMS_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTeamsDistributeDirective.h b/include/multiplier/AST/OMPTeamsDistributeDirective.h
index 61d106c6d..771da2f24 100644
--- a/include/multiplier/AST/OMPTeamsDistributeDirective.h
+++ b/include/multiplier/AST/OMPTeamsDistributeDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTeamsDistributeDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTeamsDistributeDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTeamsDistributeDirective : public OMPLoopDirective {
   static gap::generator<OMPTeamsDistributeDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTeamsDistributeDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTeamsDistributeDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTeamsDistributeDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TEAMS_DISTRIBUTE_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTeamsDistributeParallelForDirective.h b/include/multiplier/AST/OMPTeamsDistributeParallelForDirective.h
index 375934f4c..996da7628 100644
--- a/include/multiplier/AST/OMPTeamsDistributeParallelForDirective.h
+++ b/include/multiplier/AST/OMPTeamsDistributeParallelForDirective.h
@@ -22,11 +22,6 @@ class OMPLoopDirective;
 class OMPTeamsDistributeParallelForDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTeamsDistributeParallelForDirective : public OMPLoopDirective {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT OMPTeamsDistributeParallelForDirective : public OMPLoopDirective
   static gap::generator<OMPTeamsDistributeParallelForDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTeamsDistributeParallelForDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTeamsDistributeParallelForDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTeamsDistributeParallelForDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTeamsDistributeParallelForSimdDirective.h b/include/multiplier/AST/OMPTeamsDistributeParallelForSimdDirective.h
index 5fd6e7b25..64b69666b 100644
--- a/include/multiplier/AST/OMPTeamsDistributeParallelForSimdDirective.h
+++ b/include/multiplier/AST/OMPTeamsDistributeParallelForSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTeamsDistributeParallelForSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTeamsDistributeParallelForSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTeamsDistributeParallelForSimdDirective : public OMPLoopDirec
   static gap::generator<OMPTeamsDistributeParallelForSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTeamsDistributeParallelForSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTeamsDistributeParallelForSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTeamsDistributeParallelForSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTeamsDistributeSimdDirective.h b/include/multiplier/AST/OMPTeamsDistributeSimdDirective.h
index 4a0051dae..2408981b4 100644
--- a/include/multiplier/AST/OMPTeamsDistributeSimdDirective.h
+++ b/include/multiplier/AST/OMPTeamsDistributeSimdDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTeamsDistributeSimdDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTeamsDistributeSimdDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTeamsDistributeSimdDirective : public OMPLoopDirective {
   static gap::generator<OMPTeamsDistributeSimdDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTeamsDistributeSimdDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTeamsDistributeSimdDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTeamsDistributeSimdDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPTeamsGenericLoopDirective.h b/include/multiplier/AST/OMPTeamsGenericLoopDirective.h
index d9330108a..2a1b77153 100644
--- a/include/multiplier/AST/OMPTeamsGenericLoopDirective.h
+++ b/include/multiplier/AST/OMPTeamsGenericLoopDirective.h
@@ -21,11 +21,6 @@ class OMPLoopDirective;
 class OMPTeamsGenericLoopDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTeamsGenericLoopDirective : public OMPLoopDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTeamsGenericLoopDirective : public OMPLoopDirective {
   static gap::generator<OMPTeamsGenericLoopDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTeamsGenericLoopDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTeamsGenericLoopDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTeamsGenericLoopDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TEAMS_GENERIC_LOOP_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPThreadPrivateDecl.h b/include/multiplier/AST/OMPThreadPrivateDecl.h
index a89e9a65b..b1f2f1367 100644
--- a/include/multiplier/AST/OMPThreadPrivateDecl.h
+++ b/include/multiplier/AST/OMPThreadPrivateDecl.h
@@ -20,11 +20,6 @@ class OMPDeclarativeDirectiveDecl;
 class OMPThreadPrivateDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPThreadPrivateDecl : public OMPDeclarativeDirectiveDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT OMPThreadPrivateDecl : public OMPDeclarativeDirectiveDecl {
   static gap::generator<OMPThreadPrivateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPThreadPrivateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPThreadPrivateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPThreadPrivateDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OMP_THREAD_PRIVATE;
   }
diff --git a/include/multiplier/AST/OMPThreadPrivateDeclAttr.h b/include/multiplier/AST/OMPThreadPrivateDeclAttr.h
index 39473103c..84d6e0fb8 100644
--- a/include/multiplier/AST/OMPThreadPrivateDeclAttr.h
+++ b/include/multiplier/AST/OMPThreadPrivateDeclAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OMPThreadPrivateDeclAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPThreadPrivateDeclAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OMPTileDirective.h b/include/multiplier/AST/OMPTileDirective.h
index 61f6798a9..2c26197b2 100644
--- a/include/multiplier/AST/OMPTileDirective.h
+++ b/include/multiplier/AST/OMPTileDirective.h
@@ -21,11 +21,6 @@ class OMPLoopTransformationDirective;
 class OMPTileDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPTileDirective : public OMPLoopTransformationDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPTileDirective : public OMPLoopTransformationDirective {
   static gap::generator<OMPTileDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPTileDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPTileDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPTileDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_TILE_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OMPUnrollDirective.h b/include/multiplier/AST/OMPUnrollDirective.h
index 5b93e6e87..297af8730 100644
--- a/include/multiplier/AST/OMPUnrollDirective.h
+++ b/include/multiplier/AST/OMPUnrollDirective.h
@@ -21,11 +21,6 @@ class OMPLoopTransformationDirective;
 class OMPUnrollDirective;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OMPUnrollDirective : public OMPLoopTransformationDirective {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OMPUnrollDirective : public OMPLoopTransformationDirective {
   static gap::generator<OMPUnrollDirective> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OMPUnrollDirective> from(const ir::Operation &op);
-  static gap::generator<std::pair<OMPUnrollDirective, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OMPUnrollDirective> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OMP_UNROLL_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/OSConsumedAttr.h b/include/multiplier/AST/OSConsumedAttr.h
index 56d5878fd..4e8b5742a 100644
--- a/include/multiplier/AST/OSConsumedAttr.h
+++ b/include/multiplier/AST/OSConsumedAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class InheritableParamAttr;
 class OSConsumedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OSConsumedAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/OSConsumesThisAttr.h b/include/multiplier/AST/OSConsumesThisAttr.h
index adf6173f5..de8e5ea01 100644
--- a/include/multiplier/AST/OSConsumesThisAttr.h
+++ b/include/multiplier/AST/OSConsumesThisAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OSConsumesThisAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OSConsumesThisAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OSReturnsNotRetainedAttr.h b/include/multiplier/AST/OSReturnsNotRetainedAttr.h
index f53f5dc93..793fc8803 100644
--- a/include/multiplier/AST/OSReturnsNotRetainedAttr.h
+++ b/include/multiplier/AST/OSReturnsNotRetainedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OSReturnsNotRetainedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OSReturnsNotRetainedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OSReturnsRetainedAttr.h b/include/multiplier/AST/OSReturnsRetainedAttr.h
index b28bddd08..a202d0b36 100644
--- a/include/multiplier/AST/OSReturnsRetainedAttr.h
+++ b/include/multiplier/AST/OSReturnsRetainedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OSReturnsRetainedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OSReturnsRetainedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OSReturnsRetainedOnNonZeroAttr.h b/include/multiplier/AST/OSReturnsRetainedOnNonZeroAttr.h
index a15986f91..2f83d3f92 100644
--- a/include/multiplier/AST/OSReturnsRetainedOnNonZeroAttr.h
+++ b/include/multiplier/AST/OSReturnsRetainedOnNonZeroAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OSReturnsRetainedOnNonZeroAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OSReturnsRetainedOnNonZeroAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OSReturnsRetainedOnZeroAttr.h b/include/multiplier/AST/OSReturnsRetainedOnZeroAttr.h
index 1c4345a38..b88c4b067 100644
--- a/include/multiplier/AST/OSReturnsRetainedOnZeroAttr.h
+++ b/include/multiplier/AST/OSReturnsRetainedOnZeroAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OSReturnsRetainedOnZeroAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OSReturnsRetainedOnZeroAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCArrayLiteral.h b/include/multiplier/AST/ObjCArrayLiteral.h
index d0799747b..b1539d8f7 100644
--- a/include/multiplier/AST/ObjCArrayLiteral.h
+++ b/include/multiplier/AST/ObjCArrayLiteral.h
@@ -21,11 +21,6 @@ class ObjCMethodDecl;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCArrayLiteral : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ObjCArrayLiteral : public Expr {
   static gap::generator<ObjCArrayLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCArrayLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCArrayLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCArrayLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_ARRAY_LITERAL;
   }
diff --git a/include/multiplier/AST/ObjCAtCatchStmt.h b/include/multiplier/AST/ObjCAtCatchStmt.h
index 959eb2277..39a2a79a7 100644
--- a/include/multiplier/AST/ObjCAtCatchStmt.h
+++ b/include/multiplier/AST/ObjCAtCatchStmt.h
@@ -19,11 +19,6 @@ class ObjCAtCatchStmt;
 class Stmt;
 class Token;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCAtCatchStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT ObjCAtCatchStmt : public Stmt {
   static gap::generator<ObjCAtCatchStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCAtCatchStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCAtCatchStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCAtCatchStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_AT_CATCH_STMT;
   }
diff --git a/include/multiplier/AST/ObjCAtDefsFieldDecl.h b/include/multiplier/AST/ObjCAtDefsFieldDecl.h
index 8de62638c..c6ed211f1 100644
--- a/include/multiplier/AST/ObjCAtDefsFieldDecl.h
+++ b/include/multiplier/AST/ObjCAtDefsFieldDecl.h
@@ -22,11 +22,6 @@ class ObjCAtDefsFieldDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCAtDefsFieldDecl : public FieldDecl {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT ObjCAtDefsFieldDecl : public FieldDecl {
   static gap::generator<ObjCAtDefsFieldDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCAtDefsFieldDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCAtDefsFieldDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCAtDefsFieldDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_AT_DEFS_FIELD;
   }
diff --git a/include/multiplier/AST/ObjCAtFinallyStmt.h b/include/multiplier/AST/ObjCAtFinallyStmt.h
index ce4e72158..cca27650a 100644
--- a/include/multiplier/AST/ObjCAtFinallyStmt.h
+++ b/include/multiplier/AST/ObjCAtFinallyStmt.h
@@ -18,11 +18,6 @@ class File;
 class ObjCAtFinallyStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCAtFinallyStmt : public Stmt {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT ObjCAtFinallyStmt : public Stmt {
   static gap::generator<ObjCAtFinallyStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCAtFinallyStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCAtFinallyStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCAtFinallyStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_AT_FINALLY_STMT;
   }
diff --git a/include/multiplier/AST/ObjCAtSynchronizedStmt.h b/include/multiplier/AST/ObjCAtSynchronizedStmt.h
index 6508d8a58..8cb15ec12 100644
--- a/include/multiplier/AST/ObjCAtSynchronizedStmt.h
+++ b/include/multiplier/AST/ObjCAtSynchronizedStmt.h
@@ -20,11 +20,6 @@ class File;
 class ObjCAtSynchronizedStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCAtSynchronizedStmt : public Stmt {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT ObjCAtSynchronizedStmt : public Stmt {
   static gap::generator<ObjCAtSynchronizedStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCAtSynchronizedStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCAtSynchronizedStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCAtSynchronizedStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_AT_SYNCHRONIZED_STMT;
   }
diff --git a/include/multiplier/AST/ObjCAtThrowStmt.h b/include/multiplier/AST/ObjCAtThrowStmt.h
index ee0f45783..c94ae8404 100644
--- a/include/multiplier/AST/ObjCAtThrowStmt.h
+++ b/include/multiplier/AST/ObjCAtThrowStmt.h
@@ -19,11 +19,6 @@ class File;
 class ObjCAtThrowStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCAtThrowStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT ObjCAtThrowStmt : public Stmt {
   static gap::generator<ObjCAtThrowStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCAtThrowStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCAtThrowStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCAtThrowStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_AT_THROW_STMT;
   }
diff --git a/include/multiplier/AST/ObjCAtTryStmt.h b/include/multiplier/AST/ObjCAtTryStmt.h
index 15783544e..5009da2a2 100644
--- a/include/multiplier/AST/ObjCAtTryStmt.h
+++ b/include/multiplier/AST/ObjCAtTryStmt.h
@@ -20,11 +20,6 @@ class ObjCAtFinallyStmt;
 class ObjCAtTryStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCAtTryStmt : public Stmt {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT ObjCAtTryStmt : public Stmt {
   static gap::generator<ObjCAtTryStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCAtTryStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCAtTryStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCAtTryStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_AT_TRY_STMT;
   }
diff --git a/include/multiplier/AST/ObjCAutoreleasePoolStmt.h b/include/multiplier/AST/ObjCAutoreleasePoolStmt.h
index 8d8252960..c24b29ef8 100644
--- a/include/multiplier/AST/ObjCAutoreleasePoolStmt.h
+++ b/include/multiplier/AST/ObjCAutoreleasePoolStmt.h
@@ -18,11 +18,6 @@ class File;
 class ObjCAutoreleasePoolStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCAutoreleasePoolStmt : public Stmt {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT ObjCAutoreleasePoolStmt : public Stmt {
   static gap::generator<ObjCAutoreleasePoolStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCAutoreleasePoolStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCAutoreleasePoolStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCAutoreleasePoolStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_AUTORELEASE_POOL_STMT;
   }
diff --git a/include/multiplier/AST/ObjCAvailabilityCheckExpr.h b/include/multiplier/AST/ObjCAvailabilityCheckExpr.h
index c6c55c18f..9abf9c3b3 100644
--- a/include/multiplier/AST/ObjCAvailabilityCheckExpr.h
+++ b/include/multiplier/AST/ObjCAvailabilityCheckExpr.h
@@ -20,11 +20,6 @@ class ObjCAvailabilityCheckExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCAvailabilityCheckExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ObjCAvailabilityCheckExpr : public Expr {
   static gap::generator<ObjCAvailabilityCheckExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCAvailabilityCheckExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCAvailabilityCheckExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCAvailabilityCheckExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_AVAILABILITY_CHECK_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCBoolLiteralExpr.h b/include/multiplier/AST/ObjCBoolLiteralExpr.h
index bf630a16f..41c494b9e 100644
--- a/include/multiplier/AST/ObjCBoolLiteralExpr.h
+++ b/include/multiplier/AST/ObjCBoolLiteralExpr.h
@@ -20,11 +20,6 @@ class ObjCBoolLiteralExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCBoolLiteralExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ObjCBoolLiteralExpr : public Expr {
   static gap::generator<ObjCBoolLiteralExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCBoolLiteralExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCBoolLiteralExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCBoolLiteralExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_BOOL_LITERAL_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCBoxableAttr.h b/include/multiplier/AST/ObjCBoxableAttr.h
index b92703c38..d20d9328b 100644
--- a/include/multiplier/AST/ObjCBoxableAttr.h
+++ b/include/multiplier/AST/ObjCBoxableAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ObjCBoxableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCBoxableAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ObjCBoxedExpr.h b/include/multiplier/AST/ObjCBoxedExpr.h
index 2abf4a362..d4a30c1fd 100644
--- a/include/multiplier/AST/ObjCBoxedExpr.h
+++ b/include/multiplier/AST/ObjCBoxedExpr.h
@@ -21,11 +21,6 @@ class ObjCMethodDecl;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCBoxedExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ObjCBoxedExpr : public Expr {
   static gap::generator<ObjCBoxedExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCBoxedExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCBoxedExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCBoxedExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_BOXED_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCBridgeAttr.h b/include/multiplier/AST/ObjCBridgeAttr.h
index 4ca41776d..c1bdee748 100644
--- a/include/multiplier/AST/ObjCBridgeAttr.h
+++ b/include/multiplier/AST/ObjCBridgeAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCBridgeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCBridgeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCBridgeMutableAttr.h b/include/multiplier/AST/ObjCBridgeMutableAttr.h
index 1cc9c83b8..af0c9223f 100644
--- a/include/multiplier/AST/ObjCBridgeMutableAttr.h
+++ b/include/multiplier/AST/ObjCBridgeMutableAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCBridgeMutableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCBridgeMutableAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCBridgeRelatedAttr.h b/include/multiplier/AST/ObjCBridgeRelatedAttr.h
index 4d97bf7ec..fe0f4a1f7 100644
--- a/include/multiplier/AST/ObjCBridgeRelatedAttr.h
+++ b/include/multiplier/AST/ObjCBridgeRelatedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCBridgeRelatedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCBridgeRelatedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCBridgedCastExpr.h b/include/multiplier/AST/ObjCBridgedCastExpr.h
index ee2983279..8b2d84c6b 100644
--- a/include/multiplier/AST/ObjCBridgedCastExpr.h
+++ b/include/multiplier/AST/ObjCBridgedCastExpr.h
@@ -23,11 +23,6 @@ class ObjCBridgedCastExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCBridgedCastExpr : public ExplicitCastExpr {
  private:
@@ -44,8 +39,7 @@ class MX_EXPORT ObjCBridgedCastExpr : public ExplicitCastExpr {
   static gap::generator<ObjCBridgedCastExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCBridgedCastExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCBridgedCastExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCBridgedCastExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_BRIDGED_CAST_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCCategoryDecl.h b/include/multiplier/AST/ObjCCategoryDecl.h
index b15097ebd..290147841 100644
--- a/include/multiplier/AST/ObjCCategoryDecl.h
+++ b/include/multiplier/AST/ObjCCategoryDecl.h
@@ -26,11 +26,6 @@ class ObjCProtocolDecl;
 class Stmt;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCCategoryDecl : public ObjCContainerDecl {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT ObjCCategoryDecl : public ObjCContainerDecl {
   static gap::generator<ObjCCategoryDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCCategoryDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCCategoryDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCCategoryDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_CATEGORY;
   }
diff --git a/include/multiplier/AST/ObjCCategoryImplDecl.h b/include/multiplier/AST/ObjCCategoryImplDecl.h
index 6edbfa4e5..763c16ebe 100644
--- a/include/multiplier/AST/ObjCCategoryImplDecl.h
+++ b/include/multiplier/AST/ObjCCategoryImplDecl.h
@@ -23,11 +23,6 @@ class ObjCContainerDecl;
 class ObjCImplDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCCategoryImplDecl : public ObjCImplDecl {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT ObjCCategoryImplDecl : public ObjCImplDecl {
   static gap::generator<ObjCCategoryImplDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCCategoryImplDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCCategoryImplDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCCategoryImplDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_CATEGORY_IMPL;
   }
diff --git a/include/multiplier/AST/ObjCClassStubAttr.h b/include/multiplier/AST/ObjCClassStubAttr.h
index 2e0bbe6c7..98ee93168 100644
--- a/include/multiplier/AST/ObjCClassStubAttr.h
+++ b/include/multiplier/AST/ObjCClassStubAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ObjCClassStubAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCClassStubAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ObjCCompatibleAliasDecl.h b/include/multiplier/AST/ObjCCompatibleAliasDecl.h
index ec86dccdc..7f519c4a8 100644
--- a/include/multiplier/AST/ObjCCompatibleAliasDecl.h
+++ b/include/multiplier/AST/ObjCCompatibleAliasDecl.h
@@ -20,11 +20,6 @@ class ObjCCompatibleAliasDecl;
 class ObjCInterfaceDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCCompatibleAliasDecl : public NamedDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT ObjCCompatibleAliasDecl : public NamedDecl {
   static gap::generator<ObjCCompatibleAliasDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCCompatibleAliasDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCCompatibleAliasDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCCompatibleAliasDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_COMPATIBLE_ALIAS;
   }
diff --git a/include/multiplier/AST/ObjCContainerDecl.h b/include/multiplier/AST/ObjCContainerDecl.h
index 92ed23e80..85c9a885b 100644
--- a/include/multiplier/AST/ObjCContainerDecl.h
+++ b/include/multiplier/AST/ObjCContainerDecl.h
@@ -23,11 +23,6 @@ class ObjCPropertyDecl;
 class Stmt;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCContainerDecl : public NamedDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT ObjCContainerDecl : public NamedDecl {
   static gap::generator<ObjCContainerDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCContainerDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCContainerDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCContainerDecl> in(const Compilation &tu);
   static gap::generator<ObjCContainerDecl> containing(const Decl &decl);
   static gap::generator<ObjCContainerDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/ObjCDesignatedInitializerAttr.h b/include/multiplier/AST/ObjCDesignatedInitializerAttr.h
index 6c263148c..fe5c9d796 100644
--- a/include/multiplier/AST/ObjCDesignatedInitializerAttr.h
+++ b/include/multiplier/AST/ObjCDesignatedInitializerAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ObjCDesignatedInitializerAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCDesignatedInitializerAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ObjCDictionaryLiteral.h b/include/multiplier/AST/ObjCDictionaryLiteral.h
index fba7f90b6..f0abd16bf 100644
--- a/include/multiplier/AST/ObjCDictionaryLiteral.h
+++ b/include/multiplier/AST/ObjCDictionaryLiteral.h
@@ -21,11 +21,6 @@ class ObjCMethodDecl;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCDictionaryLiteral : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ObjCDictionaryLiteral : public Expr {
   static gap::generator<ObjCDictionaryLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCDictionaryLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCDictionaryLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCDictionaryLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_DICTIONARY_LITERAL;
   }
diff --git a/include/multiplier/AST/ObjCDirectAttr.h b/include/multiplier/AST/ObjCDirectAttr.h
index 1a6d1f9fe..c33289881 100644
--- a/include/multiplier/AST/ObjCDirectAttr.h
+++ b/include/multiplier/AST/ObjCDirectAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ObjCDirectAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCDirectAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ObjCDirectMembersAttr.h b/include/multiplier/AST/ObjCDirectMembersAttr.h
index 9dc04fbad..f781f9fb4 100644
--- a/include/multiplier/AST/ObjCDirectMembersAttr.h
+++ b/include/multiplier/AST/ObjCDirectMembersAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ObjCDirectMembersAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCDirectMembersAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ObjCEncodeExpr.h b/include/multiplier/AST/ObjCEncodeExpr.h
index a66bcf334..9b4a54b17 100644
--- a/include/multiplier/AST/ObjCEncodeExpr.h
+++ b/include/multiplier/AST/ObjCEncodeExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCEncodeExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ObjCEncodeExpr : public Expr {
   static gap::generator<ObjCEncodeExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCEncodeExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCEncodeExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCEncodeExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_ENCODE_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCExceptionAttr.h b/include/multiplier/AST/ObjCExceptionAttr.h
index dd3283eeb..925528359 100644
--- a/include/multiplier/AST/ObjCExceptionAttr.h
+++ b/include/multiplier/AST/ObjCExceptionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCExceptionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCExceptionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCExplicitProtocolImplAttr.h b/include/multiplier/AST/ObjCExplicitProtocolImplAttr.h
index 40c80b36b..314514a79 100644
--- a/include/multiplier/AST/ObjCExplicitProtocolImplAttr.h
+++ b/include/multiplier/AST/ObjCExplicitProtocolImplAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCExplicitProtocolImplAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCExplicitProtocolImplAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCExternallyRetainedAttr.h b/include/multiplier/AST/ObjCExternallyRetainedAttr.h
index e9443bee5..a6a0efca9 100644
--- a/include/multiplier/AST/ObjCExternallyRetainedAttr.h
+++ b/include/multiplier/AST/ObjCExternallyRetainedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCExternallyRetainedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCExternallyRetainedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCForCollectionStmt.h b/include/multiplier/AST/ObjCForCollectionStmt.h
index 83296028e..9b72819a6 100644
--- a/include/multiplier/AST/ObjCForCollectionStmt.h
+++ b/include/multiplier/AST/ObjCForCollectionStmt.h
@@ -19,11 +19,6 @@ class File;
 class ObjCForCollectionStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCForCollectionStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT ObjCForCollectionStmt : public Stmt {
   static gap::generator<ObjCForCollectionStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCForCollectionStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCForCollectionStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCForCollectionStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_FOR_COLLECTION_STMT;
   }
diff --git a/include/multiplier/AST/ObjCGCAttr.h b/include/multiplier/AST/ObjCGCAttr.h
index 61df19231..4721fb123 100644
--- a/include/multiplier/AST/ObjCGCAttr.h
+++ b/include/multiplier/AST/ObjCGCAttr.h
@@ -18,11 +18,6 @@ class File;
 class ObjCGCAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCGCAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ObjCImplDecl.h b/include/multiplier/AST/ObjCImplDecl.h
index eb2569962..90574805a 100644
--- a/include/multiplier/AST/ObjCImplDecl.h
+++ b/include/multiplier/AST/ObjCImplDecl.h
@@ -23,11 +23,6 @@ class ObjCInterfaceDecl;
 class ObjCPropertyImplDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCImplDecl : public ObjCContainerDecl {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT ObjCImplDecl : public ObjCContainerDecl {
   static gap::generator<ObjCImplDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCImplDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCImplDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCImplDecl> in(const Compilation &tu);
   static gap::generator<ObjCImplDecl> containing(const Decl &decl);
   static gap::generator<ObjCImplDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/ObjCImplementationDecl.h b/include/multiplier/AST/ObjCImplementationDecl.h
index e7b495942..c610f6530 100644
--- a/include/multiplier/AST/ObjCImplementationDecl.h
+++ b/include/multiplier/AST/ObjCImplementationDecl.h
@@ -25,11 +25,6 @@ class ObjCInterfaceDecl;
 class ObjCIvarDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCImplementationDecl : public ObjCImplDecl {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT ObjCImplementationDecl : public ObjCImplDecl {
   static gap::generator<ObjCImplementationDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCImplementationDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCImplementationDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCImplementationDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_IMPLEMENTATION;
   }
diff --git a/include/multiplier/AST/ObjCIndependentClassAttr.h b/include/multiplier/AST/ObjCIndependentClassAttr.h
index fbcbab04b..9b8060a1d 100644
--- a/include/multiplier/AST/ObjCIndependentClassAttr.h
+++ b/include/multiplier/AST/ObjCIndependentClassAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCIndependentClassAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCIndependentClassAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCIndirectCopyRestoreExpr.h b/include/multiplier/AST/ObjCIndirectCopyRestoreExpr.h
index a2d8adff3..20423c65a 100644
--- a/include/multiplier/AST/ObjCIndirectCopyRestoreExpr.h
+++ b/include/multiplier/AST/ObjCIndirectCopyRestoreExpr.h
@@ -20,11 +20,6 @@ class ObjCIndirectCopyRestoreExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCIndirectCopyRestoreExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ObjCIndirectCopyRestoreExpr : public Expr {
   static gap::generator<ObjCIndirectCopyRestoreExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCIndirectCopyRestoreExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCIndirectCopyRestoreExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCIndirectCopyRestoreExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_INDIRECT_COPY_RESTORE_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCInertUnsafeUnretainedAttr.h b/include/multiplier/AST/ObjCInertUnsafeUnretainedAttr.h
index cba8fe7d2..1a046a39a 100644
--- a/include/multiplier/AST/ObjCInertUnsafeUnretainedAttr.h
+++ b/include/multiplier/AST/ObjCInertUnsafeUnretainedAttr.h
@@ -18,11 +18,6 @@ class File;
 class ObjCInertUnsafeUnretainedAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCInertUnsafeUnretainedAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ObjCInterfaceDecl.h b/include/multiplier/AST/ObjCInterfaceDecl.h
index a5a5afb23..349a3ca4c 100644
--- a/include/multiplier/AST/ObjCInterfaceDecl.h
+++ b/include/multiplier/AST/ObjCInterfaceDecl.h
@@ -27,11 +27,6 @@ class Stmt;
 class Token;
 class TokenRange;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCInterfaceDecl : public ObjCContainerDecl {
  private:
@@ -46,8 +41,7 @@ class MX_EXPORT ObjCInterfaceDecl : public ObjCContainerDecl {
   static gap::generator<ObjCInterfaceDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCInterfaceDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCInterfaceDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCInterfaceDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_INTERFACE;
   }
diff --git a/include/multiplier/AST/ObjCInterfaceType.h b/include/multiplier/AST/ObjCInterfaceType.h
index 005668c50..f8797764b 100644
--- a/include/multiplier/AST/ObjCInterfaceType.h
+++ b/include/multiplier/AST/ObjCInterfaceType.h
@@ -18,11 +18,6 @@ class ObjCInterfaceType;
 class ObjCObjectType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCInterfaceType : public ObjCObjectType {
  private:
diff --git a/include/multiplier/AST/ObjCIsaExpr.h b/include/multiplier/AST/ObjCIsaExpr.h
index 304b4e418..b7fb5998c 100644
--- a/include/multiplier/AST/ObjCIsaExpr.h
+++ b/include/multiplier/AST/ObjCIsaExpr.h
@@ -20,11 +20,6 @@ class ObjCIsaExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCIsaExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ObjCIsaExpr : public Expr {
   static gap::generator<ObjCIsaExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCIsaExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCIsaExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCIsaExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_ISA_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCIvarDecl.h b/include/multiplier/AST/ObjCIvarDecl.h
index 99b43feb9..6b38566e2 100644
--- a/include/multiplier/AST/ObjCIvarDecl.h
+++ b/include/multiplier/AST/ObjCIvarDecl.h
@@ -24,11 +24,6 @@ class ObjCIvarDecl;
 class Stmt;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCIvarDecl : public FieldDecl {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT ObjCIvarDecl : public FieldDecl {
   static gap::generator<ObjCIvarDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCIvarDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCIvarDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCIvarDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_IVAR;
   }
diff --git a/include/multiplier/AST/ObjCIvarRefExpr.h b/include/multiplier/AST/ObjCIvarRefExpr.h
index ba358f9d7..e413687df 100644
--- a/include/multiplier/AST/ObjCIvarRefExpr.h
+++ b/include/multiplier/AST/ObjCIvarRefExpr.h
@@ -21,11 +21,6 @@ class ObjCIvarRefExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCIvarRefExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ObjCIvarRefExpr : public Expr {
   static gap::generator<ObjCIvarRefExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCIvarRefExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCIvarRefExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCIvarRefExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_IVAR_REF_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCKindOfAttr.h b/include/multiplier/AST/ObjCKindOfAttr.h
index e05eb59f8..2f66eb707 100644
--- a/include/multiplier/AST/ObjCKindOfAttr.h
+++ b/include/multiplier/AST/ObjCKindOfAttr.h
@@ -18,11 +18,6 @@ class File;
 class ObjCKindOfAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCKindOfAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/ObjCMessageExpr.h b/include/multiplier/AST/ObjCMessageExpr.h
index 70bda3a6e..3468da203 100644
--- a/include/multiplier/AST/ObjCMessageExpr.h
+++ b/include/multiplier/AST/ObjCMessageExpr.h
@@ -26,11 +26,6 @@ class Token;
 class TokenRange;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCMessageExpr : public Expr {
  private:
@@ -45,8 +40,7 @@ class MX_EXPORT ObjCMessageExpr : public Expr {
   static gap::generator<ObjCMessageExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCMessageExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCMessageExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCMessageExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_MESSAGE_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCMethodDecl.h b/include/multiplier/AST/ObjCMethodDecl.h
index dbd36e469..c7ae4ad79 100644
--- a/include/multiplier/AST/ObjCMethodDecl.h
+++ b/include/multiplier/AST/ObjCMethodDecl.h
@@ -29,11 +29,6 @@ class Stmt;
 class Token;
 class TokenRange;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCMethodDecl : public NamedDecl {
  private:
@@ -47,8 +42,7 @@ class MX_EXPORT ObjCMethodDecl : public NamedDecl {
   static gap::generator<ObjCMethodDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCMethodDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCMethodDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCMethodDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_METHOD;
   }
diff --git a/include/multiplier/AST/ObjCMethodFamilyAttr.h b/include/multiplier/AST/ObjCMethodFamilyAttr.h
index cde772cda..223680fc2 100644
--- a/include/multiplier/AST/ObjCMethodFamilyAttr.h
+++ b/include/multiplier/AST/ObjCMethodFamilyAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class ObjCMethodFamilyAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCMethodFamilyAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCNSObjectAttr.h b/include/multiplier/AST/ObjCNSObjectAttr.h
index 3b8f400dc..c5de303eb 100644
--- a/include/multiplier/AST/ObjCNSObjectAttr.h
+++ b/include/multiplier/AST/ObjCNSObjectAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCNSObjectAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCNSObjectAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCNonLazyClassAttr.h b/include/multiplier/AST/ObjCNonLazyClassAttr.h
index 39d25f1e4..d818de901 100644
--- a/include/multiplier/AST/ObjCNonLazyClassAttr.h
+++ b/include/multiplier/AST/ObjCNonLazyClassAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ObjCNonLazyClassAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCNonLazyClassAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ObjCNonRuntimeProtocolAttr.h b/include/multiplier/AST/ObjCNonRuntimeProtocolAttr.h
index e50a9d5c4..195dc33e2 100644
--- a/include/multiplier/AST/ObjCNonRuntimeProtocolAttr.h
+++ b/include/multiplier/AST/ObjCNonRuntimeProtocolAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ObjCNonRuntimeProtocolAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCNonRuntimeProtocolAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ObjCObjectPointerType.h b/include/multiplier/AST/ObjCObjectPointerType.h
index b9d41969c..3bba1e39f 100644
--- a/include/multiplier/AST/ObjCObjectPointerType.h
+++ b/include/multiplier/AST/ObjCObjectPointerType.h
@@ -20,11 +20,6 @@ class ObjCObjectType;
 class ObjCProtocolDecl;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCObjectPointerType : public Type {
  private:
diff --git a/include/multiplier/AST/ObjCObjectType.h b/include/multiplier/AST/ObjCObjectType.h
index 3593bd5fb..48054779c 100644
--- a/include/multiplier/AST/ObjCObjectType.h
+++ b/include/multiplier/AST/ObjCObjectType.h
@@ -17,11 +17,6 @@ class ObjCInterfaceDecl;
 class ObjCObjectType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCObjectType : public Type {
  private:
diff --git a/include/multiplier/AST/ObjCOwnershipAttr.h b/include/multiplier/AST/ObjCOwnershipAttr.h
index 83932646a..97ad8dfba 100644
--- a/include/multiplier/AST/ObjCOwnershipAttr.h
+++ b/include/multiplier/AST/ObjCOwnershipAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCOwnershipAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCOwnershipAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCPreciseLifetimeAttr.h b/include/multiplier/AST/ObjCPreciseLifetimeAttr.h
index 8ced7b851..443b3824b 100644
--- a/include/multiplier/AST/ObjCPreciseLifetimeAttr.h
+++ b/include/multiplier/AST/ObjCPreciseLifetimeAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCPreciseLifetimeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCPreciseLifetimeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCPropertyDecl.h b/include/multiplier/AST/ObjCPropertyDecl.h
index 300692037..a0a60594c 100644
--- a/include/multiplier/AST/ObjCPropertyDecl.h
+++ b/include/multiplier/AST/ObjCPropertyDecl.h
@@ -25,11 +25,6 @@ class ObjCPropertyDecl;
 class Stmt;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCPropertyDecl : public NamedDecl {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT ObjCPropertyDecl : public NamedDecl {
   static gap::generator<ObjCPropertyDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCPropertyDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCPropertyDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCPropertyDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_PROPERTY;
   }
diff --git a/include/multiplier/AST/ObjCPropertyImplDecl.h b/include/multiplier/AST/ObjCPropertyImplDecl.h
index 20c733f3c..48c8661f4 100644
--- a/include/multiplier/AST/ObjCPropertyImplDecl.h
+++ b/include/multiplier/AST/ObjCPropertyImplDecl.h
@@ -23,11 +23,6 @@ class ObjCPropertyDecl;
 class ObjCPropertyImplDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCPropertyImplDecl : public Decl {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ObjCPropertyImplDecl : public Decl {
   static gap::generator<ObjCPropertyImplDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCPropertyImplDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCPropertyImplDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCPropertyImplDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_PROPERTY_IMPL;
   }
diff --git a/include/multiplier/AST/ObjCPropertyRefExpr.h b/include/multiplier/AST/ObjCPropertyRefExpr.h
index 2e66928f3..afe2e1811 100644
--- a/include/multiplier/AST/ObjCPropertyRefExpr.h
+++ b/include/multiplier/AST/ObjCPropertyRefExpr.h
@@ -24,11 +24,6 @@ class Stmt;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCPropertyRefExpr : public Expr {
  private:
@@ -43,8 +38,7 @@ class MX_EXPORT ObjCPropertyRefExpr : public Expr {
   static gap::generator<ObjCPropertyRefExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCPropertyRefExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCPropertyRefExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCPropertyRefExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_PROPERTY_REF_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCProtocolDecl.h b/include/multiplier/AST/ObjCProtocolDecl.h
index bc64b6865..183fe0eaf 100644
--- a/include/multiplier/AST/ObjCProtocolDecl.h
+++ b/include/multiplier/AST/ObjCProtocolDecl.h
@@ -22,11 +22,6 @@ class ObjCProtocolDecl;
 class Stmt;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCProtocolDecl : public ObjCContainerDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT ObjCProtocolDecl : public ObjCContainerDecl {
   static gap::generator<ObjCProtocolDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCProtocolDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCProtocolDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCProtocolDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_PROTOCOL;
   }
diff --git a/include/multiplier/AST/ObjCProtocolExpr.h b/include/multiplier/AST/ObjCProtocolExpr.h
index b64efb0ad..1da58e4fb 100644
--- a/include/multiplier/AST/ObjCProtocolExpr.h
+++ b/include/multiplier/AST/ObjCProtocolExpr.h
@@ -21,11 +21,6 @@ class ObjCProtocolExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCProtocolExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ObjCProtocolExpr : public Expr {
   static gap::generator<ObjCProtocolExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCProtocolExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCProtocolExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCProtocolExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_PROTOCOL_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCRequiresPropertyDefsAttr.h b/include/multiplier/AST/ObjCRequiresPropertyDefsAttr.h
index 96125a925..e797d0195 100644
--- a/include/multiplier/AST/ObjCRequiresPropertyDefsAttr.h
+++ b/include/multiplier/AST/ObjCRequiresPropertyDefsAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCRequiresPropertyDefsAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCRequiresPropertyDefsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCRequiresSuperAttr.h b/include/multiplier/AST/ObjCRequiresSuperAttr.h
index 025f82cf3..76a74df85 100644
--- a/include/multiplier/AST/ObjCRequiresSuperAttr.h
+++ b/include/multiplier/AST/ObjCRequiresSuperAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCRequiresSuperAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCRequiresSuperAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCReturnsInnerPointerAttr.h b/include/multiplier/AST/ObjCReturnsInnerPointerAttr.h
index 6f637ebda..b22841144 100644
--- a/include/multiplier/AST/ObjCReturnsInnerPointerAttr.h
+++ b/include/multiplier/AST/ObjCReturnsInnerPointerAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCReturnsInnerPointerAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCReturnsInnerPointerAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCRootClassAttr.h b/include/multiplier/AST/ObjCRootClassAttr.h
index a34d2d68a..c26b5b6e9 100644
--- a/include/multiplier/AST/ObjCRootClassAttr.h
+++ b/include/multiplier/AST/ObjCRootClassAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCRootClassAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCRootClassAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCRuntimeNameAttr.h b/include/multiplier/AST/ObjCRuntimeNameAttr.h
index 922b86197..9de7f7999 100644
--- a/include/multiplier/AST/ObjCRuntimeNameAttr.h
+++ b/include/multiplier/AST/ObjCRuntimeNameAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ObjCRuntimeNameAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCRuntimeNameAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ObjCRuntimeVisibleAttr.h b/include/multiplier/AST/ObjCRuntimeVisibleAttr.h
index c482c6ebc..14e9006eb 100644
--- a/include/multiplier/AST/ObjCRuntimeVisibleAttr.h
+++ b/include/multiplier/AST/ObjCRuntimeVisibleAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ObjCRuntimeVisibleAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCRuntimeVisibleAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ObjCSelectorExpr.h b/include/multiplier/AST/ObjCSelectorExpr.h
index 077756c51..53b942435 100644
--- a/include/multiplier/AST/ObjCSelectorExpr.h
+++ b/include/multiplier/AST/ObjCSelectorExpr.h
@@ -20,11 +20,6 @@ class ObjCSelectorExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCSelectorExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ObjCSelectorExpr : public Expr {
   static gap::generator<ObjCSelectorExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCSelectorExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCSelectorExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCSelectorExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_SELECTOR_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCStringLiteral.h b/include/multiplier/AST/ObjCStringLiteral.h
index 9639613d5..1328a9ab2 100644
--- a/include/multiplier/AST/ObjCStringLiteral.h
+++ b/include/multiplier/AST/ObjCStringLiteral.h
@@ -21,11 +21,6 @@ class Stmt;
 class StringLiteral;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCStringLiteral : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ObjCStringLiteral : public Expr {
   static gap::generator<ObjCStringLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCStringLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCStringLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCStringLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_STRING_LITERAL;
   }
diff --git a/include/multiplier/AST/ObjCSubclassingRestrictedAttr.h b/include/multiplier/AST/ObjCSubclassingRestrictedAttr.h
index 243654ea4..5ae582ab4 100644
--- a/include/multiplier/AST/ObjCSubclassingRestrictedAttr.h
+++ b/include/multiplier/AST/ObjCSubclassingRestrictedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ObjCSubclassingRestrictedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCSubclassingRestrictedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ObjCSubscriptRefExpr.h b/include/multiplier/AST/ObjCSubscriptRefExpr.h
index 693f71c41..e20023ad1 100644
--- a/include/multiplier/AST/ObjCSubscriptRefExpr.h
+++ b/include/multiplier/AST/ObjCSubscriptRefExpr.h
@@ -21,11 +21,6 @@ class ObjCSubscriptRefExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCSubscriptRefExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT ObjCSubscriptRefExpr : public Expr {
   static gap::generator<ObjCSubscriptRefExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCSubscriptRefExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCSubscriptRefExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCSubscriptRefExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OBJ_C_SUBSCRIPT_REF_EXPR;
   }
diff --git a/include/multiplier/AST/ObjCTypeParamDecl.h b/include/multiplier/AST/ObjCTypeParamDecl.h
index cec5f26b1..470854ffa 100644
--- a/include/multiplier/AST/ObjCTypeParamDecl.h
+++ b/include/multiplier/AST/ObjCTypeParamDecl.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class TypeDecl;
 class TypedefNameDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCTypeParamDecl : public TypedefNameDecl {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT ObjCTypeParamDecl : public TypedefNameDecl {
   static gap::generator<ObjCTypeParamDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ObjCTypeParamDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ObjCTypeParamDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ObjCTypeParamDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::OBJ_C_TYPE_PARAM;
   }
diff --git a/include/multiplier/AST/ObjCTypeParamType.h b/include/multiplier/AST/ObjCTypeParamType.h
index 7df325297..9a1bcb66c 100644
--- a/include/multiplier/AST/ObjCTypeParamType.h
+++ b/include/multiplier/AST/ObjCTypeParamType.h
@@ -17,11 +17,6 @@ class ObjCTypeParamDecl;
 class ObjCTypeParamType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ObjCTypeParamType : public Type {
  private:
diff --git a/include/multiplier/AST/OffsetOfExpr.h b/include/multiplier/AST/OffsetOfExpr.h
index c065866ad..f8d6b163e 100644
--- a/include/multiplier/AST/OffsetOfExpr.h
+++ b/include/multiplier/AST/OffsetOfExpr.h
@@ -20,11 +20,6 @@ class OffsetOfExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OffsetOfExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT OffsetOfExpr : public Expr {
   static gap::generator<OffsetOfExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OffsetOfExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<OffsetOfExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OffsetOfExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OFFSET_OF_EXPR;
   }
diff --git a/include/multiplier/AST/OpaqueValueExpr.h b/include/multiplier/AST/OpaqueValueExpr.h
index 6dd96083e..be6036ec2 100644
--- a/include/multiplier/AST/OpaqueValueExpr.h
+++ b/include/multiplier/AST/OpaqueValueExpr.h
@@ -20,11 +20,6 @@ class OpaqueValueExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpaqueValueExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT OpaqueValueExpr : public Expr {
   static gap::generator<OpaqueValueExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OpaqueValueExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<OpaqueValueExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OpaqueValueExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::OPAQUE_VALUE_EXPR;
   }
diff --git a/include/multiplier/AST/OpenCLAccessAttr.h b/include/multiplier/AST/OpenCLAccessAttr.h
index b9831ceb5..92cecfc1f 100644
--- a/include/multiplier/AST/OpenCLAccessAttr.h
+++ b/include/multiplier/AST/OpenCLAccessAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class OpenCLAccessAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLAccessAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/OpenCLConstantAddressSpaceAttr.h b/include/multiplier/AST/OpenCLConstantAddressSpaceAttr.h
index 919201fa1..ed5e77c79 100644
--- a/include/multiplier/AST/OpenCLConstantAddressSpaceAttr.h
+++ b/include/multiplier/AST/OpenCLConstantAddressSpaceAttr.h
@@ -19,11 +19,6 @@ class File;
 class OpenCLConstantAddressSpaceAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLConstantAddressSpaceAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/OpenCLGenericAddressSpaceAttr.h b/include/multiplier/AST/OpenCLGenericAddressSpaceAttr.h
index 5f2a58b85..c699e6ff6 100644
--- a/include/multiplier/AST/OpenCLGenericAddressSpaceAttr.h
+++ b/include/multiplier/AST/OpenCLGenericAddressSpaceAttr.h
@@ -19,11 +19,6 @@ class File;
 class OpenCLGenericAddressSpaceAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLGenericAddressSpaceAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/OpenCLGlobalAddressSpaceAttr.h b/include/multiplier/AST/OpenCLGlobalAddressSpaceAttr.h
index 6e11e562b..64788a01c 100644
--- a/include/multiplier/AST/OpenCLGlobalAddressSpaceAttr.h
+++ b/include/multiplier/AST/OpenCLGlobalAddressSpaceAttr.h
@@ -19,11 +19,6 @@ class File;
 class OpenCLGlobalAddressSpaceAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLGlobalAddressSpaceAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/OpenCLGlobalDeviceAddressSpaceAttr.h b/include/multiplier/AST/OpenCLGlobalDeviceAddressSpaceAttr.h
index 0d0cba402..de68eebbe 100644
--- a/include/multiplier/AST/OpenCLGlobalDeviceAddressSpaceAttr.h
+++ b/include/multiplier/AST/OpenCLGlobalDeviceAddressSpaceAttr.h
@@ -18,11 +18,6 @@ class File;
 class OpenCLGlobalDeviceAddressSpaceAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLGlobalDeviceAddressSpaceAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/OpenCLGlobalHostAddressSpaceAttr.h b/include/multiplier/AST/OpenCLGlobalHostAddressSpaceAttr.h
index 76ae8c810..f13ff380a 100644
--- a/include/multiplier/AST/OpenCLGlobalHostAddressSpaceAttr.h
+++ b/include/multiplier/AST/OpenCLGlobalHostAddressSpaceAttr.h
@@ -18,11 +18,6 @@ class File;
 class OpenCLGlobalHostAddressSpaceAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLGlobalHostAddressSpaceAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/OpenCLIntelReqdSubGroupSizeAttr.h b/include/multiplier/AST/OpenCLIntelReqdSubGroupSizeAttr.h
index 88bb5a2d9..d5b8d7461 100644
--- a/include/multiplier/AST/OpenCLIntelReqdSubGroupSizeAttr.h
+++ b/include/multiplier/AST/OpenCLIntelReqdSubGroupSizeAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OpenCLIntelReqdSubGroupSizeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLIntelReqdSubGroupSizeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OpenCLKernelAttr.h b/include/multiplier/AST/OpenCLKernelAttr.h
index 1504123ac..febee253c 100644
--- a/include/multiplier/AST/OpenCLKernelAttr.h
+++ b/include/multiplier/AST/OpenCLKernelAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OpenCLKernelAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLKernelAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OpenCLLocalAddressSpaceAttr.h b/include/multiplier/AST/OpenCLLocalAddressSpaceAttr.h
index c6110d964..8a86edceb 100644
--- a/include/multiplier/AST/OpenCLLocalAddressSpaceAttr.h
+++ b/include/multiplier/AST/OpenCLLocalAddressSpaceAttr.h
@@ -19,11 +19,6 @@ class File;
 class OpenCLLocalAddressSpaceAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLLocalAddressSpaceAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/OpenCLPrivateAddressSpaceAttr.h b/include/multiplier/AST/OpenCLPrivateAddressSpaceAttr.h
index 5d28d96e1..8fe8aadbc 100644
--- a/include/multiplier/AST/OpenCLPrivateAddressSpaceAttr.h
+++ b/include/multiplier/AST/OpenCLPrivateAddressSpaceAttr.h
@@ -19,11 +19,6 @@ class File;
 class OpenCLPrivateAddressSpaceAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLPrivateAddressSpaceAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/OpenCLUnrollHintAttr.h b/include/multiplier/AST/OpenCLUnrollHintAttr.h
index 1f4b76d22..2201069fc 100644
--- a/include/multiplier/AST/OpenCLUnrollHintAttr.h
+++ b/include/multiplier/AST/OpenCLUnrollHintAttr.h
@@ -18,11 +18,6 @@ class File;
 class OpenCLUnrollHintAttr;
 class StmtAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OpenCLUnrollHintAttr : public StmtAttr {
  private:
diff --git a/include/multiplier/AST/OptimizeNoneAttr.h b/include/multiplier/AST/OptimizeNoneAttr.h
index d9197ad9c..ec516a168 100644
--- a/include/multiplier/AST/OptimizeNoneAttr.h
+++ b/include/multiplier/AST/OptimizeNoneAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OptimizeNoneAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OptimizeNoneAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OverloadExpr.h b/include/multiplier/AST/OverloadExpr.h
index 48202807c..84cb66270 100644
--- a/include/multiplier/AST/OverloadExpr.h
+++ b/include/multiplier/AST/OverloadExpr.h
@@ -22,11 +22,6 @@ class OverloadExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OverloadExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT OverloadExpr : public Expr {
   static gap::generator<OverloadExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<OverloadExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<OverloadExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<OverloadExpr> in(const Compilation &tu);
   static gap::generator<OverloadExpr> containing(const Decl &decl);
   static gap::generator<OverloadExpr> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/OverloadableAttr.h b/include/multiplier/AST/OverloadableAttr.h
index 5be3c9302..d38220749 100644
--- a/include/multiplier/AST/OverloadableAttr.h
+++ b/include/multiplier/AST/OverloadableAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class OverloadableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OverloadableAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/OverrideAttr.h b/include/multiplier/AST/OverrideAttr.h
index 1ce35b5ae..aaec48d8a 100644
--- a/include/multiplier/AST/OverrideAttr.h
+++ b/include/multiplier/AST/OverrideAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class OverrideAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OverrideAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OwnerAttr.h b/include/multiplier/AST/OwnerAttr.h
index 8b2c6093d..685caa0eb 100644
--- a/include/multiplier/AST/OwnerAttr.h
+++ b/include/multiplier/AST/OwnerAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class OwnerAttr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OwnerAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/OwnershipAttr.h b/include/multiplier/AST/OwnershipAttr.h
index 368622f0b..9581d9549 100644
--- a/include/multiplier/AST/OwnershipAttr.h
+++ b/include/multiplier/AST/OwnershipAttr.h
@@ -20,11 +20,6 @@ class File;
 class InheritableAttr;
 class OwnershipAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OwnershipAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PackExpansionExpr.h b/include/multiplier/AST/PackExpansionExpr.h
index 8592a544e..01ba4b8d9 100644
--- a/include/multiplier/AST/PackExpansionExpr.h
+++ b/include/multiplier/AST/PackExpansionExpr.h
@@ -20,11 +20,6 @@ class PackExpansionExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PackExpansionExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT PackExpansionExpr : public Expr {
   static gap::generator<PackExpansionExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<PackExpansionExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<PackExpansionExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<PackExpansionExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::PACK_EXPANSION_EXPR;
   }
diff --git a/include/multiplier/AST/PackExpansionType.h b/include/multiplier/AST/PackExpansionType.h
index 4e53d1472..f4535111b 100644
--- a/include/multiplier/AST/PackExpansionType.h
+++ b/include/multiplier/AST/PackExpansionType.h
@@ -16,11 +16,6 @@ class Index;
 class PackExpansionType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PackExpansionType : public Type {
  private:
diff --git a/include/multiplier/AST/PackedAttr.h b/include/multiplier/AST/PackedAttr.h
index 3f3336472..1d9d5f4d7 100644
--- a/include/multiplier/AST/PackedAttr.h
+++ b/include/multiplier/AST/PackedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PackedAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PackedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ParamTypestateAttr.h b/include/multiplier/AST/ParamTypestateAttr.h
index 4f658a002..9d8bfa9d0 100644
--- a/include/multiplier/AST/ParamTypestateAttr.h
+++ b/include/multiplier/AST/ParamTypestateAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class ParamTypestateAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ParamTypestateAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ParameterABIAttr.h b/include/multiplier/AST/ParameterABIAttr.h
index 24d83f9a3..d9a2ce05a 100644
--- a/include/multiplier/AST/ParameterABIAttr.h
+++ b/include/multiplier/AST/ParameterABIAttr.h
@@ -20,11 +20,6 @@ class InheritableAttr;
 class InheritableParamAttr;
 class ParameterABIAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ParameterABIAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/ParenExpr.h b/include/multiplier/AST/ParenExpr.h
index 307ab781a..353acdce6 100644
--- a/include/multiplier/AST/ParenExpr.h
+++ b/include/multiplier/AST/ParenExpr.h
@@ -20,11 +20,6 @@ class ParenExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ParenExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ParenExpr : public Expr {
   static gap::generator<ParenExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ParenExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ParenExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ParenExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::PAREN_EXPR;
   }
diff --git a/include/multiplier/AST/ParenListExpr.h b/include/multiplier/AST/ParenListExpr.h
index edced7bb3..3c063687e 100644
--- a/include/multiplier/AST/ParenListExpr.h
+++ b/include/multiplier/AST/ParenListExpr.h
@@ -20,11 +20,6 @@ class ParenListExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ParenListExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ParenListExpr : public Expr {
   static gap::generator<ParenListExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ParenListExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ParenListExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ParenListExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::PAREN_LIST_EXPR;
   }
diff --git a/include/multiplier/AST/ParenType.h b/include/multiplier/AST/ParenType.h
index 36bf6194c..1927f0aec 100644
--- a/include/multiplier/AST/ParenType.h
+++ b/include/multiplier/AST/ParenType.h
@@ -16,11 +16,6 @@ class Index;
 class ParenType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ParenType : public Type {
  private:
diff --git a/include/multiplier/AST/ParmVarDecl.h b/include/multiplier/AST/ParmVarDecl.h
index b08f07c69..1b5ae63c5 100644
--- a/include/multiplier/AST/ParmVarDecl.h
+++ b/include/multiplier/AST/ParmVarDecl.h
@@ -26,11 +26,6 @@ class TokenRange;
 class Type;
 class ValueDecl;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ParmVarDecl : public VarDecl {
  private:
@@ -47,8 +42,7 @@ class MX_EXPORT ParmVarDecl : public VarDecl {
   static gap::generator<ParmVarDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ParmVarDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ParmVarDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ParmVarDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::PARM_VAR;
   }
diff --git a/include/multiplier/AST/PascalAttr.h b/include/multiplier/AST/PascalAttr.h
index a044bb78c..ae90f89fb 100644
--- a/include/multiplier/AST/PascalAttr.h
+++ b/include/multiplier/AST/PascalAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PascalAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PascalAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PassObjectSizeAttr.h b/include/multiplier/AST/PassObjectSizeAttr.h
index dcec48a05..9e172db30 100644
--- a/include/multiplier/AST/PassObjectSizeAttr.h
+++ b/include/multiplier/AST/PassObjectSizeAttr.h
@@ -20,11 +20,6 @@ class InheritableAttr;
 class InheritableParamAttr;
 class PassObjectSizeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PassObjectSizeAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/PatchableFunctionEntryAttr.h b/include/multiplier/AST/PatchableFunctionEntryAttr.h
index 4fd57c53b..6c4fe5687 100644
--- a/include/multiplier/AST/PatchableFunctionEntryAttr.h
+++ b/include/multiplier/AST/PatchableFunctionEntryAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PatchableFunctionEntryAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PatchableFunctionEntryAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PcsAttr.h b/include/multiplier/AST/PcsAttr.h
index ec4d05b59..a0b7d6bbe 100644
--- a/include/multiplier/AST/PcsAttr.h
+++ b/include/multiplier/AST/PcsAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class PcsAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PcsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PipeType.h b/include/multiplier/AST/PipeType.h
index d3b9a004d..4416513aa 100644
--- a/include/multiplier/AST/PipeType.h
+++ b/include/multiplier/AST/PipeType.h
@@ -16,11 +16,6 @@ class Index;
 class PipeType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PipeType : public Type {
  private:
diff --git a/include/multiplier/AST/PointerAttr.h b/include/multiplier/AST/PointerAttr.h
index d874af690..3de197b75 100644
--- a/include/multiplier/AST/PointerAttr.h
+++ b/include/multiplier/AST/PointerAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class PointerAttr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PointerAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PointerType.h b/include/multiplier/AST/PointerType.h
index e4e8b51f8..09234fa68 100644
--- a/include/multiplier/AST/PointerType.h
+++ b/include/multiplier/AST/PointerType.h
@@ -16,11 +16,6 @@ class Index;
 class PointerType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PointerType : public Type {
  private:
diff --git a/include/multiplier/AST/PragmaClangBSSSectionAttr.h b/include/multiplier/AST/PragmaClangBSSSectionAttr.h
index 217572cd9..82107ab09 100644
--- a/include/multiplier/AST/PragmaClangBSSSectionAttr.h
+++ b/include/multiplier/AST/PragmaClangBSSSectionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PragmaClangBSSSectionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PragmaClangBSSSectionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PragmaClangDataSectionAttr.h b/include/multiplier/AST/PragmaClangDataSectionAttr.h
index 12c7a6f81..61587f342 100644
--- a/include/multiplier/AST/PragmaClangDataSectionAttr.h
+++ b/include/multiplier/AST/PragmaClangDataSectionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PragmaClangDataSectionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PragmaClangDataSectionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PragmaClangRelroSectionAttr.h b/include/multiplier/AST/PragmaClangRelroSectionAttr.h
index 1abd5eadd..95a8e8f49 100644
--- a/include/multiplier/AST/PragmaClangRelroSectionAttr.h
+++ b/include/multiplier/AST/PragmaClangRelroSectionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PragmaClangRelroSectionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PragmaClangRelroSectionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PragmaClangRodataSectionAttr.h b/include/multiplier/AST/PragmaClangRodataSectionAttr.h
index 49b78a114..8f9f7b502 100644
--- a/include/multiplier/AST/PragmaClangRodataSectionAttr.h
+++ b/include/multiplier/AST/PragmaClangRodataSectionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PragmaClangRodataSectionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PragmaClangRodataSectionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PragmaClangTextSectionAttr.h b/include/multiplier/AST/PragmaClangTextSectionAttr.h
index a3541dc24..5824699f9 100644
--- a/include/multiplier/AST/PragmaClangTextSectionAttr.h
+++ b/include/multiplier/AST/PragmaClangTextSectionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PragmaClangTextSectionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PragmaClangTextSectionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PragmaCommentDecl.h b/include/multiplier/AST/PragmaCommentDecl.h
index d551b2d4b..9d4793fc8 100644
--- a/include/multiplier/AST/PragmaCommentDecl.h
+++ b/include/multiplier/AST/PragmaCommentDecl.h
@@ -19,11 +19,6 @@ class File;
 class PragmaCommentDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PragmaCommentDecl : public Decl {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT PragmaCommentDecl : public Decl {
   static gap::generator<PragmaCommentDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<PragmaCommentDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<PragmaCommentDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<PragmaCommentDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::PRAGMA_COMMENT;
   }
diff --git a/include/multiplier/AST/PragmaDetectMismatchDecl.h b/include/multiplier/AST/PragmaDetectMismatchDecl.h
index cbfbf6e0a..6c4613a86 100644
--- a/include/multiplier/AST/PragmaDetectMismatchDecl.h
+++ b/include/multiplier/AST/PragmaDetectMismatchDecl.h
@@ -18,11 +18,6 @@ class File;
 class PragmaDetectMismatchDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PragmaDetectMismatchDecl : public Decl {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT PragmaDetectMismatchDecl : public Decl {
   static gap::generator<PragmaDetectMismatchDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<PragmaDetectMismatchDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<PragmaDetectMismatchDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<PragmaDetectMismatchDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::PRAGMA_DETECT_MISMATCH;
   }
diff --git a/include/multiplier/AST/PredefinedExpr.h b/include/multiplier/AST/PredefinedExpr.h
index 605f45693..08fcaa7a0 100644
--- a/include/multiplier/AST/PredefinedExpr.h
+++ b/include/multiplier/AST/PredefinedExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class StringLiteral;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PredefinedExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT PredefinedExpr : public Expr {
   static gap::generator<PredefinedExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<PredefinedExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<PredefinedExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<PredefinedExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::PREDEFINED_EXPR;
   }
diff --git a/include/multiplier/AST/PreferredNameAttr.h b/include/multiplier/AST/PreferredNameAttr.h
index 1de0be53f..511e11ea0 100644
--- a/include/multiplier/AST/PreferredNameAttr.h
+++ b/include/multiplier/AST/PreferredNameAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class PreferredNameAttr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PreferredNameAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PreferredTypeAttr.h b/include/multiplier/AST/PreferredTypeAttr.h
index bc100897d..12019dc1b 100644
--- a/include/multiplier/AST/PreferredTypeAttr.h
+++ b/include/multiplier/AST/PreferredTypeAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class PreferredTypeAttr;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PreferredTypeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PreserveAllAttr.h b/include/multiplier/AST/PreserveAllAttr.h
index 2bc22ebd7..fdcffec43 100644
--- a/include/multiplier/AST/PreserveAllAttr.h
+++ b/include/multiplier/AST/PreserveAllAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PreserveAllAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PreserveAllAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PreserveMostAttr.h b/include/multiplier/AST/PreserveMostAttr.h
index 72dd4dea5..a0abe18d2 100644
--- a/include/multiplier/AST/PreserveMostAttr.h
+++ b/include/multiplier/AST/PreserveMostAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PreserveMostAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PreserveMostAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PseudoObjectExpr.h b/include/multiplier/AST/PseudoObjectExpr.h
index e6a21419d..87be13213 100644
--- a/include/multiplier/AST/PseudoObjectExpr.h
+++ b/include/multiplier/AST/PseudoObjectExpr.h
@@ -20,11 +20,6 @@ class PseudoObjectExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PseudoObjectExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT PseudoObjectExpr : public Expr {
   static gap::generator<PseudoObjectExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<PseudoObjectExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<PseudoObjectExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<PseudoObjectExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::PSEUDO_OBJECT_EXPR;
   }
diff --git a/include/multiplier/AST/PtGuardedByAttr.h b/include/multiplier/AST/PtGuardedByAttr.h
index f6a6b12b4..9a0c9dee0 100644
--- a/include/multiplier/AST/PtGuardedByAttr.h
+++ b/include/multiplier/AST/PtGuardedByAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class PtGuardedByAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PtGuardedByAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/PtGuardedVarAttr.h b/include/multiplier/AST/PtGuardedVarAttr.h
index 48449b4c2..3663fe843 100644
--- a/include/multiplier/AST/PtGuardedVarAttr.h
+++ b/include/multiplier/AST/PtGuardedVarAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PtGuardedVarAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PtGuardedVarAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/Ptr32Attr.h b/include/multiplier/AST/Ptr32Attr.h
index 3c2bbdfa2..4455d7a72 100644
--- a/include/multiplier/AST/Ptr32Attr.h
+++ b/include/multiplier/AST/Ptr32Attr.h
@@ -18,11 +18,6 @@ class File;
 class Ptr32Attr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT Ptr32Attr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/Ptr64Attr.h b/include/multiplier/AST/Ptr64Attr.h
index 20678c8cd..d2f1204cd 100644
--- a/include/multiplier/AST/Ptr64Attr.h
+++ b/include/multiplier/AST/Ptr64Attr.h
@@ -18,11 +18,6 @@ class File;
 class Ptr64Attr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT Ptr64Attr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/PureAttr.h b/include/multiplier/AST/PureAttr.h
index d68af9802..b7d693ba7 100644
--- a/include/multiplier/AST/PureAttr.h
+++ b/include/multiplier/AST/PureAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class PureAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PureAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/QualifiedType.h b/include/multiplier/AST/QualifiedType.h
index 4598896cc..4ee259be5 100644
--- a/include/multiplier/AST/QualifiedType.h
+++ b/include/multiplier/AST/QualifiedType.h
@@ -17,11 +17,6 @@ class Index;
 class QualifiedType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT QualifiedType : public Type {
  private:
diff --git a/include/multiplier/AST/RISCVInterruptAttr.h b/include/multiplier/AST/RISCVInterruptAttr.h
index 5a2b0f9f9..8fed1487e 100644
--- a/include/multiplier/AST/RISCVInterruptAttr.h
+++ b/include/multiplier/AST/RISCVInterruptAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class RISCVInterruptAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RISCVInterruptAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/RValueReferenceType.h b/include/multiplier/AST/RValueReferenceType.h
index cc09972c5..f57e08ed2 100644
--- a/include/multiplier/AST/RValueReferenceType.h
+++ b/include/multiplier/AST/RValueReferenceType.h
@@ -17,11 +17,6 @@ class RValueReferenceType;
 class ReferenceType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RValueReferenceType : public ReferenceType {
  private:
diff --git a/include/multiplier/AST/RandomizeLayoutAttr.h b/include/multiplier/AST/RandomizeLayoutAttr.h
index 4e4c5a3a3..5623c0a67 100644
--- a/include/multiplier/AST/RandomizeLayoutAttr.h
+++ b/include/multiplier/AST/RandomizeLayoutAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class RandomizeLayoutAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RandomizeLayoutAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ReadOnlyPlacementAttr.h b/include/multiplier/AST/ReadOnlyPlacementAttr.h
index 87bf4086d..26f0eb288 100644
--- a/include/multiplier/AST/ReadOnlyPlacementAttr.h
+++ b/include/multiplier/AST/ReadOnlyPlacementAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ReadOnlyPlacementAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReadOnlyPlacementAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/RecordDecl.h b/include/multiplier/AST/RecordDecl.h
index 743b486b5..0ce7c443e 100644
--- a/include/multiplier/AST/RecordDecl.h
+++ b/include/multiplier/AST/RecordDecl.h
@@ -24,11 +24,6 @@ class Stmt;
 class TagDecl;
 class Token;
 class TypeDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RecordDecl : public TagDecl {
  private:
@@ -44,8 +39,7 @@ class MX_EXPORT RecordDecl : public TagDecl {
   static gap::generator<RecordDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<RecordDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<RecordDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<RecordDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::RECORD;
   }
diff --git a/include/multiplier/AST/RecordType.h b/include/multiplier/AST/RecordType.h
index 2b1c72531..b48bed34f 100644
--- a/include/multiplier/AST/RecordType.h
+++ b/include/multiplier/AST/RecordType.h
@@ -17,11 +17,6 @@ class RecordType;
 class TagType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RecordType : public TagType {
  private:
diff --git a/include/multiplier/AST/RecoveryExpr.h b/include/multiplier/AST/RecoveryExpr.h
index e5e9f0d97..91cbb9da5 100644
--- a/include/multiplier/AST/RecoveryExpr.h
+++ b/include/multiplier/AST/RecoveryExpr.h
@@ -20,11 +20,6 @@ class RecoveryExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RecoveryExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT RecoveryExpr : public Expr {
   static gap::generator<RecoveryExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<RecoveryExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<RecoveryExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<RecoveryExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::RECOVERY_EXPR;
   }
diff --git a/include/multiplier/AST/RedeclarableTemplateDecl.h b/include/multiplier/AST/RedeclarableTemplateDecl.h
index 317c761a8..0f1e6127c 100644
--- a/include/multiplier/AST/RedeclarableTemplateDecl.h
+++ b/include/multiplier/AST/RedeclarableTemplateDecl.h
@@ -20,11 +20,6 @@ class RedeclarableTemplateDecl;
 class Stmt;
 class TemplateDecl;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RedeclarableTemplateDecl : public TemplateDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT RedeclarableTemplateDecl : public TemplateDecl {
   static gap::generator<RedeclarableTemplateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<RedeclarableTemplateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<RedeclarableTemplateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<RedeclarableTemplateDecl> in(const Compilation &tu);
   static gap::generator<RedeclarableTemplateDecl> containing(const Decl &decl);
   static gap::generator<RedeclarableTemplateDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/ReferenceType.h b/include/multiplier/AST/ReferenceType.h
index fa2a4801f..d62dd0fd3 100644
--- a/include/multiplier/AST/ReferenceType.h
+++ b/include/multiplier/AST/ReferenceType.h
@@ -16,11 +16,6 @@ class Index;
 class ReferenceType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReferenceType : public Type {
  private:
diff --git a/include/multiplier/AST/RegCallAttr.h b/include/multiplier/AST/RegCallAttr.h
index c739d506f..7595eeae7 100644
--- a/include/multiplier/AST/RegCallAttr.h
+++ b/include/multiplier/AST/RegCallAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class RegCallAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RegCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ReinitializesAttr.h b/include/multiplier/AST/ReinitializesAttr.h
index 823b16bf3..010c189bf 100644
--- a/include/multiplier/AST/ReinitializesAttr.h
+++ b/include/multiplier/AST/ReinitializesAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ReinitializesAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReinitializesAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ReleaseCapabilityAttr.h b/include/multiplier/AST/ReleaseCapabilityAttr.h
index 145af6d26..e7730fa95 100644
--- a/include/multiplier/AST/ReleaseCapabilityAttr.h
+++ b/include/multiplier/AST/ReleaseCapabilityAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class ReleaseCapabilityAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReleaseCapabilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ReleaseHandleAttr.h b/include/multiplier/AST/ReleaseHandleAttr.h
index 46aaa52b1..0e5a01e49 100644
--- a/include/multiplier/AST/ReleaseHandleAttr.h
+++ b/include/multiplier/AST/ReleaseHandleAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class InheritableParamAttr;
 class ReleaseHandleAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReleaseHandleAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/RenderScriptKernelAttr.h b/include/multiplier/AST/RenderScriptKernelAttr.h
index a5f4d5a4d..dc0d7ec79 100644
--- a/include/multiplier/AST/RenderScriptKernelAttr.h
+++ b/include/multiplier/AST/RenderScriptKernelAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class RenderScriptKernelAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RenderScriptKernelAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/ReqdWorkGroupSizeAttr.h b/include/multiplier/AST/ReqdWorkGroupSizeAttr.h
index 604ed284e..dedeb4c45 100644
--- a/include/multiplier/AST/ReqdWorkGroupSizeAttr.h
+++ b/include/multiplier/AST/ReqdWorkGroupSizeAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ReqdWorkGroupSizeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReqdWorkGroupSizeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/RequiresCapabilityAttr.h b/include/multiplier/AST/RequiresCapabilityAttr.h
index 219af3dcc..a8a1ac703 100644
--- a/include/multiplier/AST/RequiresCapabilityAttr.h
+++ b/include/multiplier/AST/RequiresCapabilityAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class RequiresCapabilityAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RequiresCapabilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/RequiresExpr.h b/include/multiplier/AST/RequiresExpr.h
index 87e6fea06..141cde591 100644
--- a/include/multiplier/AST/RequiresExpr.h
+++ b/include/multiplier/AST/RequiresExpr.h
@@ -22,11 +22,6 @@ class RequiresExprBodyDecl;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RequiresExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT RequiresExpr : public Expr {
   static gap::generator<RequiresExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<RequiresExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<RequiresExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<RequiresExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::REQUIRES_EXPR;
   }
diff --git a/include/multiplier/AST/RequiresExprBodyDecl.h b/include/multiplier/AST/RequiresExprBodyDecl.h
index 808dcbb17..3686e4b9f 100644
--- a/include/multiplier/AST/RequiresExprBodyDecl.h
+++ b/include/multiplier/AST/RequiresExprBodyDecl.h
@@ -19,11 +19,6 @@ class File;
 class RequiresExprBodyDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RequiresExprBodyDecl : public Decl {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT RequiresExprBodyDecl : public Decl {
   static gap::generator<RequiresExprBodyDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<RequiresExprBodyDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<RequiresExprBodyDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<RequiresExprBodyDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::REQUIRES_EXPR_BODY;
   }
diff --git a/include/multiplier/AST/RestrictAttr.h b/include/multiplier/AST/RestrictAttr.h
index 050796805..ba21f4f58 100644
--- a/include/multiplier/AST/RestrictAttr.h
+++ b/include/multiplier/AST/RestrictAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class RestrictAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RestrictAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/RetainAttr.h b/include/multiplier/AST/RetainAttr.h
index b942cacca..8f52cbcb3 100644
--- a/include/multiplier/AST/RetainAttr.h
+++ b/include/multiplier/AST/RetainAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class RetainAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT RetainAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ReturnStmt.h b/include/multiplier/AST/ReturnStmt.h
index 87a5be40a..07fb1b297 100644
--- a/include/multiplier/AST/ReturnStmt.h
+++ b/include/multiplier/AST/ReturnStmt.h
@@ -20,11 +20,6 @@ class ReturnStmt;
 class Stmt;
 class Token;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReturnStmt : public Stmt {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT ReturnStmt : public Stmt {
   static gap::generator<ReturnStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ReturnStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ReturnStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ReturnStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::RETURN_STMT;
   }
diff --git a/include/multiplier/AST/ReturnTypestateAttr.h b/include/multiplier/AST/ReturnTypestateAttr.h
index 911e893db..25f8b2a6e 100644
--- a/include/multiplier/AST/ReturnTypestateAttr.h
+++ b/include/multiplier/AST/ReturnTypestateAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class ReturnTypestateAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReturnTypestateAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ReturnsNonNullAttr.h b/include/multiplier/AST/ReturnsNonNullAttr.h
index ab13b1372..891f9e3f0 100644
--- a/include/multiplier/AST/ReturnsNonNullAttr.h
+++ b/include/multiplier/AST/ReturnsNonNullAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ReturnsNonNullAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReturnsNonNullAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ReturnsTwiceAttr.h b/include/multiplier/AST/ReturnsTwiceAttr.h
index 1f9acbd70..544fa1210 100644
--- a/include/multiplier/AST/ReturnsTwiceAttr.h
+++ b/include/multiplier/AST/ReturnsTwiceAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ReturnsTwiceAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ReturnsTwiceAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SEHExceptStmt.h b/include/multiplier/AST/SEHExceptStmt.h
index 2c6ed5363..6b05d54f0 100644
--- a/include/multiplier/AST/SEHExceptStmt.h
+++ b/include/multiplier/AST/SEHExceptStmt.h
@@ -20,11 +20,6 @@ class File;
 class SEHExceptStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SEHExceptStmt : public Stmt {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT SEHExceptStmt : public Stmt {
   static gap::generator<SEHExceptStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SEHExceptStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<SEHExceptStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SEHExceptStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SEH_EXCEPT_STMT;
   }
diff --git a/include/multiplier/AST/SEHFinallyStmt.h b/include/multiplier/AST/SEHFinallyStmt.h
index 2be213c9d..7713bbf20 100644
--- a/include/multiplier/AST/SEHFinallyStmt.h
+++ b/include/multiplier/AST/SEHFinallyStmt.h
@@ -19,11 +19,6 @@ class File;
 class SEHFinallyStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SEHFinallyStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT SEHFinallyStmt : public Stmt {
   static gap::generator<SEHFinallyStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SEHFinallyStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<SEHFinallyStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SEHFinallyStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SEH_FINALLY_STMT;
   }
diff --git a/include/multiplier/AST/SEHLeaveStmt.h b/include/multiplier/AST/SEHLeaveStmt.h
index d2b674a22..7a34daf10 100644
--- a/include/multiplier/AST/SEHLeaveStmt.h
+++ b/include/multiplier/AST/SEHLeaveStmt.h
@@ -18,11 +18,6 @@ class File;
 class SEHLeaveStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SEHLeaveStmt : public Stmt {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT SEHLeaveStmt : public Stmt {
   static gap::generator<SEHLeaveStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SEHLeaveStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<SEHLeaveStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SEHLeaveStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SEH_LEAVE_STMT;
   }
diff --git a/include/multiplier/AST/SEHTryStmt.h b/include/multiplier/AST/SEHTryStmt.h
index 4b849ceb3..0971c87f3 100644
--- a/include/multiplier/AST/SEHTryStmt.h
+++ b/include/multiplier/AST/SEHTryStmt.h
@@ -21,11 +21,6 @@ class SEHFinallyStmt;
 class SEHTryStmt;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SEHTryStmt : public Stmt {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT SEHTryStmt : public Stmt {
   static gap::generator<SEHTryStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SEHTryStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<SEHTryStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SEHTryStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SEH_TRY_STMT;
   }
diff --git a/include/multiplier/AST/SPtrAttr.h b/include/multiplier/AST/SPtrAttr.h
index 1916907ad..2f9fa1686 100644
--- a/include/multiplier/AST/SPtrAttr.h
+++ b/include/multiplier/AST/SPtrAttr.h
@@ -18,11 +18,6 @@ class File;
 class SPtrAttr;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SPtrAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/SYCLKernelAttr.h b/include/multiplier/AST/SYCLKernelAttr.h
index d8904927e..0d56390be 100644
--- a/include/multiplier/AST/SYCLKernelAttr.h
+++ b/include/multiplier/AST/SYCLKernelAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SYCLKernelAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SYCLKernelAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SYCLSpecialClassAttr.h b/include/multiplier/AST/SYCLSpecialClassAttr.h
index 457a4dedd..551db59ea 100644
--- a/include/multiplier/AST/SYCLSpecialClassAttr.h
+++ b/include/multiplier/AST/SYCLSpecialClassAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SYCLSpecialClassAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SYCLSpecialClassAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SYCLUniqueStableNameExpr.h b/include/multiplier/AST/SYCLUniqueStableNameExpr.h
index a64e4d425..f9b5355e9 100644
--- a/include/multiplier/AST/SYCLUniqueStableNameExpr.h
+++ b/include/multiplier/AST/SYCLUniqueStableNameExpr.h
@@ -20,11 +20,6 @@ class SYCLUniqueStableNameExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SYCLUniqueStableNameExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT SYCLUniqueStableNameExpr : public Expr {
   static gap::generator<SYCLUniqueStableNameExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SYCLUniqueStableNameExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<SYCLUniqueStableNameExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SYCLUniqueStableNameExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SYCL_UNIQUE_STABLE_NAME_EXPR;
   }
diff --git a/include/multiplier/AST/ScopedLockableAttr.h b/include/multiplier/AST/ScopedLockableAttr.h
index 55d06fa87..8d4fd18c3 100644
--- a/include/multiplier/AST/ScopedLockableAttr.h
+++ b/include/multiplier/AST/ScopedLockableAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ScopedLockableAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ScopedLockableAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SectionAttr.h b/include/multiplier/AST/SectionAttr.h
index c89ea24cc..d7e5d65b2 100644
--- a/include/multiplier/AST/SectionAttr.h
+++ b/include/multiplier/AST/SectionAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class SectionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SectionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SelectAnyAttr.h b/include/multiplier/AST/SelectAnyAttr.h
index c142f1f2c..64d938477 100644
--- a/include/multiplier/AST/SelectAnyAttr.h
+++ b/include/multiplier/AST/SelectAnyAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SelectAnyAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SelectAnyAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SentinelAttr.h b/include/multiplier/AST/SentinelAttr.h
index 65cfd8435..b76604d12 100644
--- a/include/multiplier/AST/SentinelAttr.h
+++ b/include/multiplier/AST/SentinelAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SentinelAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SentinelAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SetTypestateAttr.h b/include/multiplier/AST/SetTypestateAttr.h
index 36b1460d3..72988a7c7 100644
--- a/include/multiplier/AST/SetTypestateAttr.h
+++ b/include/multiplier/AST/SetTypestateAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class SetTypestateAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SetTypestateAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SharedTrylockFunctionAttr.h b/include/multiplier/AST/SharedTrylockFunctionAttr.h
index 2ae79354f..2308b8b5b 100644
--- a/include/multiplier/AST/SharedTrylockFunctionAttr.h
+++ b/include/multiplier/AST/SharedTrylockFunctionAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class SharedTrylockFunctionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SharedTrylockFunctionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ShuffleVectorExpr.h b/include/multiplier/AST/ShuffleVectorExpr.h
index 46d95c9a3..bf791ea20 100644
--- a/include/multiplier/AST/ShuffleVectorExpr.h
+++ b/include/multiplier/AST/ShuffleVectorExpr.h
@@ -20,11 +20,6 @@ class ShuffleVectorExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ShuffleVectorExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ShuffleVectorExpr : public Expr {
   static gap::generator<ShuffleVectorExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ShuffleVectorExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<ShuffleVectorExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ShuffleVectorExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SHUFFLE_VECTOR_EXPR;
   }
diff --git a/include/multiplier/AST/SizeOfPackExpr.h b/include/multiplier/AST/SizeOfPackExpr.h
index 56b8e1ec9..b378e2e23 100644
--- a/include/multiplier/AST/SizeOfPackExpr.h
+++ b/include/multiplier/AST/SizeOfPackExpr.h
@@ -22,11 +22,6 @@ class Stmt;
 class TemplateArgument;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SizeOfPackExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT SizeOfPackExpr : public Expr {
   static gap::generator<SizeOfPackExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SizeOfPackExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<SizeOfPackExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SizeOfPackExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SIZE_OF_PACK_EXPR;
   }
diff --git a/include/multiplier/AST/SourceLocExpr.h b/include/multiplier/AST/SourceLocExpr.h
index c9e6d0b29..fd26fefe2 100644
--- a/include/multiplier/AST/SourceLocExpr.h
+++ b/include/multiplier/AST/SourceLocExpr.h
@@ -21,11 +21,6 @@ class SourceLocExpr;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SourceLocExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT SourceLocExpr : public Expr {
   static gap::generator<SourceLocExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SourceLocExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<SourceLocExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SourceLocExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SOURCE_LOC_EXPR;
   }
diff --git a/include/multiplier/AST/SpeculativeLoadHardeningAttr.h b/include/multiplier/AST/SpeculativeLoadHardeningAttr.h
index 3b003de5f..570912a6d 100644
--- a/include/multiplier/AST/SpeculativeLoadHardeningAttr.h
+++ b/include/multiplier/AST/SpeculativeLoadHardeningAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SpeculativeLoadHardeningAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SpeculativeLoadHardeningAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/StandaloneDebugAttr.h b/include/multiplier/AST/StandaloneDebugAttr.h
index 04ce4fea2..bfbb6be0f 100644
--- a/include/multiplier/AST/StandaloneDebugAttr.h
+++ b/include/multiplier/AST/StandaloneDebugAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class StandaloneDebugAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT StandaloneDebugAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/StaticAssertDecl.h b/include/multiplier/AST/StaticAssertDecl.h
index 54abb2cdb..a879eb16f 100644
--- a/include/multiplier/AST/StaticAssertDecl.h
+++ b/include/multiplier/AST/StaticAssertDecl.h
@@ -19,11 +19,6 @@ class File;
 class StaticAssertDecl;
 class Stmt;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT StaticAssertDecl : public Decl {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT StaticAssertDecl : public Decl {
   static gap::generator<StaticAssertDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<StaticAssertDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<StaticAssertDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<StaticAssertDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::STATIC_ASSERT;
   }
diff --git a/include/multiplier/AST/StdCallAttr.h b/include/multiplier/AST/StdCallAttr.h
index 3f1999e87..1ca3f74bb 100644
--- a/include/multiplier/AST/StdCallAttr.h
+++ b/include/multiplier/AST/StdCallAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class StdCallAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT StdCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/Stmt.h b/include/multiplier/AST/Stmt.h
index 87911f864..b5b54ae1c 100644
--- a/include/multiplier/AST/Stmt.h
+++ b/include/multiplier/AST/Stmt.h
@@ -34,11 +34,6 @@ class Stmt;
 class StmtImpl;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT Stmt {
  public:
@@ -56,8 +51,7 @@ class MX_EXPORT Stmt {
   friend class TokenContext;
   friend class Type;
   friend class StmtImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const StmtImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
@@ -94,9 +88,8 @@ class MX_EXPORT Stmt {
   static gap::generator<Stmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<Stmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<Stmt, ir::Operation>> in(const Compilation &tu);
-  static gap::generator<std::pair<Stmt, ir::Operation>> in(const Compilation &tu, std::span<const StmtKind> kinds);
+  static gap::generator<Stmt> in(const Compilation &tu);
+  static gap::generator<Stmt> in(const Compilation &tu, std::span<const StmtKind> kinds);
 
   static gap::generator<Stmt> containing(const Decl &decl);
   static gap::generator<Stmt> containing(const std::optional<Decl> &decl);
diff --git a/include/multiplier/AST/StmtAttr.h b/include/multiplier/AST/StmtAttr.h
index 4dd0c6c99..2b3fa6b0c 100644
--- a/include/multiplier/AST/StmtAttr.h
+++ b/include/multiplier/AST/StmtAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class StmtAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT StmtAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/StmtExpr.h b/include/multiplier/AST/StmtExpr.h
index ddb1b4070..4cadbff78 100644
--- a/include/multiplier/AST/StmtExpr.h
+++ b/include/multiplier/AST/StmtExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class StmtExpr;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT StmtExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT StmtExpr : public Expr {
   static gap::generator<StmtExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<StmtExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<StmtExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<StmtExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::STMT_EXPR;
   }
diff --git a/include/multiplier/AST/StrictFPAttr.h b/include/multiplier/AST/StrictFPAttr.h
index 7e228756f..b08859b76 100644
--- a/include/multiplier/AST/StrictFPAttr.h
+++ b/include/multiplier/AST/StrictFPAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class StrictFPAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT StrictFPAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/StrictGuardStackCheckAttr.h b/include/multiplier/AST/StrictGuardStackCheckAttr.h
index 3fb5cc5f3..0a679f5d5 100644
--- a/include/multiplier/AST/StrictGuardStackCheckAttr.h
+++ b/include/multiplier/AST/StrictGuardStackCheckAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class StrictGuardStackCheckAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT StrictGuardStackCheckAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/StringLiteral.h b/include/multiplier/AST/StringLiteral.h
index ae1d2daba..58008d0b1 100644
--- a/include/multiplier/AST/StringLiteral.h
+++ b/include/multiplier/AST/StringLiteral.h
@@ -21,11 +21,6 @@ class Stmt;
 class StringLiteral;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT StringLiteral : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT StringLiteral : public Expr {
   static gap::generator<StringLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<StringLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<StringLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<StringLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::STRING_LITERAL;
   }
diff --git a/include/multiplier/AST/SubstNonTypeTemplateParmExpr.h b/include/multiplier/AST/SubstNonTypeTemplateParmExpr.h
index a93c011dd..1b22d7365 100644
--- a/include/multiplier/AST/SubstNonTypeTemplateParmExpr.h
+++ b/include/multiplier/AST/SubstNonTypeTemplateParmExpr.h
@@ -22,11 +22,6 @@ class SubstNonTypeTemplateParmExpr;
 class Token;
 class Type;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SubstNonTypeTemplateParmExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT SubstNonTypeTemplateParmExpr : public Expr {
   static gap::generator<SubstNonTypeTemplateParmExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SubstNonTypeTemplateParmExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<SubstNonTypeTemplateParmExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SubstNonTypeTemplateParmExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SUBST_NON_TYPE_TEMPLATE_PARM_EXPR;
   }
diff --git a/include/multiplier/AST/SubstNonTypeTemplateParmPackExpr.h b/include/multiplier/AST/SubstNonTypeTemplateParmPackExpr.h
index 6c4e042bc..ec51183c8 100644
--- a/include/multiplier/AST/SubstNonTypeTemplateParmPackExpr.h
+++ b/include/multiplier/AST/SubstNonTypeTemplateParmPackExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class SubstNonTypeTemplateParmPackExpr;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SubstNonTypeTemplateParmPackExpr : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT SubstNonTypeTemplateParmPackExpr : public Expr {
   static gap::generator<SubstNonTypeTemplateParmPackExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SubstNonTypeTemplateParmPackExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<SubstNonTypeTemplateParmPackExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SubstNonTypeTemplateParmPackExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SUBST_NON_TYPE_TEMPLATE_PARM_PACK_EXPR;
   }
diff --git a/include/multiplier/AST/SubstTemplateTypeParmPackType.h b/include/multiplier/AST/SubstTemplateTypeParmPackType.h
index 57cb10faf..1ff9149a0 100644
--- a/include/multiplier/AST/SubstTemplateTypeParmPackType.h
+++ b/include/multiplier/AST/SubstTemplateTypeParmPackType.h
@@ -18,11 +18,6 @@ class SubstTemplateTypeParmPackType;
 class TemplateTypeParmDecl;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SubstTemplateTypeParmPackType : public Type {
  private:
diff --git a/include/multiplier/AST/SubstTemplateTypeParmType.h b/include/multiplier/AST/SubstTemplateTypeParmType.h
index f44b4e4d7..3f62b0c7a 100644
--- a/include/multiplier/AST/SubstTemplateTypeParmType.h
+++ b/include/multiplier/AST/SubstTemplateTypeParmType.h
@@ -18,11 +18,6 @@ class SubstTemplateTypeParmType;
 class TemplateTypeParmDecl;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SubstTemplateTypeParmType : public Type {
  private:
diff --git a/include/multiplier/AST/SuppressAttr.h b/include/multiplier/AST/SuppressAttr.h
index 806b8f123..4cc7dc547 100644
--- a/include/multiplier/AST/SuppressAttr.h
+++ b/include/multiplier/AST/SuppressAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class SuppressAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SuppressAttr : public DeclOrStmtAttr {
  private:
diff --git a/include/multiplier/AST/SwiftAsyncAttr.h b/include/multiplier/AST/SwiftAsyncAttr.h
index 16fd9ebfc..f36b38e13 100644
--- a/include/multiplier/AST/SwiftAsyncAttr.h
+++ b/include/multiplier/AST/SwiftAsyncAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class SwiftAsyncAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftAsyncAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftAsyncCallAttr.h b/include/multiplier/AST/SwiftAsyncCallAttr.h
index b2f0a9618..2109a3d98 100644
--- a/include/multiplier/AST/SwiftAsyncCallAttr.h
+++ b/include/multiplier/AST/SwiftAsyncCallAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftAsyncCallAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftAsyncCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftAsyncContextAttr.h b/include/multiplier/AST/SwiftAsyncContextAttr.h
index 71680b6e1..7696e01a6 100644
--- a/include/multiplier/AST/SwiftAsyncContextAttr.h
+++ b/include/multiplier/AST/SwiftAsyncContextAttr.h
@@ -20,11 +20,6 @@ class InheritableParamAttr;
 class ParameterABIAttr;
 class SwiftAsyncContextAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftAsyncContextAttr : public ParameterABIAttr {
  private:
diff --git a/include/multiplier/AST/SwiftAsyncErrorAttr.h b/include/multiplier/AST/SwiftAsyncErrorAttr.h
index cd448f82b..4a9599f21 100644
--- a/include/multiplier/AST/SwiftAsyncErrorAttr.h
+++ b/include/multiplier/AST/SwiftAsyncErrorAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class SwiftAsyncErrorAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftAsyncErrorAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftAsyncNameAttr.h b/include/multiplier/AST/SwiftAsyncNameAttr.h
index bccc739d1..d5d4da7f9 100644
--- a/include/multiplier/AST/SwiftAsyncNameAttr.h
+++ b/include/multiplier/AST/SwiftAsyncNameAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftAsyncNameAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftAsyncNameAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftAttrAttr.h b/include/multiplier/AST/SwiftAttrAttr.h
index deb1aef38..c0539ae8e 100644
--- a/include/multiplier/AST/SwiftAttrAttr.h
+++ b/include/multiplier/AST/SwiftAttrAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftAttrAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftAttrAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftBridgeAttr.h b/include/multiplier/AST/SwiftBridgeAttr.h
index a9f3e52a2..88e2d68a9 100644
--- a/include/multiplier/AST/SwiftBridgeAttr.h
+++ b/include/multiplier/AST/SwiftBridgeAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftBridgeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftBridgeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftBridgedTypedefAttr.h b/include/multiplier/AST/SwiftBridgedTypedefAttr.h
index 9b066aa04..d0e92351e 100644
--- a/include/multiplier/AST/SwiftBridgedTypedefAttr.h
+++ b/include/multiplier/AST/SwiftBridgedTypedefAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftBridgedTypedefAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftBridgedTypedefAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftCallAttr.h b/include/multiplier/AST/SwiftCallAttr.h
index d871e1f5b..405fb5f88 100644
--- a/include/multiplier/AST/SwiftCallAttr.h
+++ b/include/multiplier/AST/SwiftCallAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftCallAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftContextAttr.h b/include/multiplier/AST/SwiftContextAttr.h
index df57e797e..321de4558 100644
--- a/include/multiplier/AST/SwiftContextAttr.h
+++ b/include/multiplier/AST/SwiftContextAttr.h
@@ -20,11 +20,6 @@ class InheritableParamAttr;
 class ParameterABIAttr;
 class SwiftContextAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftContextAttr : public ParameterABIAttr {
  private:
diff --git a/include/multiplier/AST/SwiftErrorAttr.h b/include/multiplier/AST/SwiftErrorAttr.h
index 136fcc9ff..a7e6769d5 100644
--- a/include/multiplier/AST/SwiftErrorAttr.h
+++ b/include/multiplier/AST/SwiftErrorAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class SwiftErrorAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftErrorAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftErrorResultAttr.h b/include/multiplier/AST/SwiftErrorResultAttr.h
index a63e0944e..c2a9d9e20 100644
--- a/include/multiplier/AST/SwiftErrorResultAttr.h
+++ b/include/multiplier/AST/SwiftErrorResultAttr.h
@@ -20,11 +20,6 @@ class InheritableParamAttr;
 class ParameterABIAttr;
 class SwiftErrorResultAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftErrorResultAttr : public ParameterABIAttr {
  private:
diff --git a/include/multiplier/AST/SwiftImportAsNonGenericAttr.h b/include/multiplier/AST/SwiftImportAsNonGenericAttr.h
index 02b74e208..c51b5bee3 100644
--- a/include/multiplier/AST/SwiftImportAsNonGenericAttr.h
+++ b/include/multiplier/AST/SwiftImportAsNonGenericAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftImportAsNonGenericAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftImportAsNonGenericAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftImportPropertyAsAccessorsAttr.h b/include/multiplier/AST/SwiftImportPropertyAsAccessorsAttr.h
index 539e4561a..63f19da2f 100644
--- a/include/multiplier/AST/SwiftImportPropertyAsAccessorsAttr.h
+++ b/include/multiplier/AST/SwiftImportPropertyAsAccessorsAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftImportPropertyAsAccessorsAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftImportPropertyAsAccessorsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftIndirectResultAttr.h b/include/multiplier/AST/SwiftIndirectResultAttr.h
index a227c3f59..7598cbe13 100644
--- a/include/multiplier/AST/SwiftIndirectResultAttr.h
+++ b/include/multiplier/AST/SwiftIndirectResultAttr.h
@@ -20,11 +20,6 @@ class InheritableParamAttr;
 class ParameterABIAttr;
 class SwiftIndirectResultAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftIndirectResultAttr : public ParameterABIAttr {
  private:
diff --git a/include/multiplier/AST/SwiftNameAttr.h b/include/multiplier/AST/SwiftNameAttr.h
index ac94684c9..2230827ac 100644
--- a/include/multiplier/AST/SwiftNameAttr.h
+++ b/include/multiplier/AST/SwiftNameAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftNameAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftNameAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftNewTypeAttr.h b/include/multiplier/AST/SwiftNewTypeAttr.h
index 482845f69..400594a42 100644
--- a/include/multiplier/AST/SwiftNewTypeAttr.h
+++ b/include/multiplier/AST/SwiftNewTypeAttr.h
@@ -20,11 +20,6 @@ class File;
 class InheritableAttr;
 class SwiftNewTypeAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftNewTypeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftObjCMembersAttr.h b/include/multiplier/AST/SwiftObjCMembersAttr.h
index 7f42c79aa..138ee8f0d 100644
--- a/include/multiplier/AST/SwiftObjCMembersAttr.h
+++ b/include/multiplier/AST/SwiftObjCMembersAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class SwiftObjCMembersAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftObjCMembersAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/SwiftPrivateAttr.h b/include/multiplier/AST/SwiftPrivateAttr.h
index 232d8769c..e14eb4e6f 100644
--- a/include/multiplier/AST/SwiftPrivateAttr.h
+++ b/include/multiplier/AST/SwiftPrivateAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SwiftPrivateAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftPrivateAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/SwiftVersionedAdditionAttr.h b/include/multiplier/AST/SwiftVersionedAdditionAttr.h
index 27efc42b7..0845b7ed3 100644
--- a/include/multiplier/AST/SwiftVersionedAdditionAttr.h
+++ b/include/multiplier/AST/SwiftVersionedAdditionAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class SwiftVersionedAdditionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftVersionedAdditionAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/SwiftVersionedRemovalAttr.h b/include/multiplier/AST/SwiftVersionedRemovalAttr.h
index 13d4fea07..006f00ca6 100644
--- a/include/multiplier/AST/SwiftVersionedRemovalAttr.h
+++ b/include/multiplier/AST/SwiftVersionedRemovalAttr.h
@@ -18,11 +18,6 @@ class Attr;
 class File;
 class SwiftVersionedRemovalAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwiftVersionedRemovalAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/SwitchCase.h b/include/multiplier/AST/SwitchCase.h
index f1096debb..174d917dd 100644
--- a/include/multiplier/AST/SwitchCase.h
+++ b/include/multiplier/AST/SwitchCase.h
@@ -18,11 +18,6 @@ class File;
 class Stmt;
 class SwitchCase;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwitchCase : public Stmt {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT SwitchCase : public Stmt {
   static gap::generator<SwitchCase> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SwitchCase> from(const ir::Operation &op);
-  static gap::generator<std::pair<SwitchCase, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SwitchCase> in(const Compilation &tu);
   static gap::generator<SwitchCase> containing(const Decl &decl);
   static gap::generator<SwitchCase> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/SwitchStmt.h b/include/multiplier/AST/SwitchStmt.h
index dc71f6225..8516972f9 100644
--- a/include/multiplier/AST/SwitchStmt.h
+++ b/include/multiplier/AST/SwitchStmt.h
@@ -22,11 +22,6 @@ class SwitchCase;
 class SwitchStmt;
 class Token;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SwitchStmt : public Stmt {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT SwitchStmt : public Stmt {
   static gap::generator<SwitchStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<SwitchStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<SwitchStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<SwitchStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::SWITCH_STMT;
   }
diff --git a/include/multiplier/AST/SysVABIAttr.h b/include/multiplier/AST/SysVABIAttr.h
index 08dba0a93..1706dbc14 100644
--- a/include/multiplier/AST/SysVABIAttr.h
+++ b/include/multiplier/AST/SysVABIAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class SysVABIAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT SysVABIAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/TLSModelAttr.h b/include/multiplier/AST/TLSModelAttr.h
index bdf9e8755..409f2d848 100644
--- a/include/multiplier/AST/TLSModelAttr.h
+++ b/include/multiplier/AST/TLSModelAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class TLSModelAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TLSModelAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/TagDecl.h b/include/multiplier/AST/TagDecl.h
index a959aaa5a..3284dadbc 100644
--- a/include/multiplier/AST/TagDecl.h
+++ b/include/multiplier/AST/TagDecl.h
@@ -25,11 +25,6 @@ class Token;
 class TokenRange;
 class TypeDecl;
 class TypedefNameDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TagDecl : public TypeDecl {
  private:
@@ -44,8 +39,7 @@ class MX_EXPORT TagDecl : public TypeDecl {
   static gap::generator<TagDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TagDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TagDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TagDecl> in(const Compilation &tu);
   static gap::generator<TagDecl> containing(const Decl &decl);
   static gap::generator<TagDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/TagType.h b/include/multiplier/AST/TagType.h
index adcb6125e..4ed65a12f 100644
--- a/include/multiplier/AST/TagType.h
+++ b/include/multiplier/AST/TagType.h
@@ -17,11 +17,6 @@ class TagDecl;
 class TagType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TagType : public Type {
  private:
diff --git a/include/multiplier/AST/TargetAttr.h b/include/multiplier/AST/TargetAttr.h
index e9cc841aa..ba19d3b87 100644
--- a/include/multiplier/AST/TargetAttr.h
+++ b/include/multiplier/AST/TargetAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class TargetAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TargetAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/TargetClonesAttr.h b/include/multiplier/AST/TargetClonesAttr.h
index c385c3ca0..38c3098da 100644
--- a/include/multiplier/AST/TargetClonesAttr.h
+++ b/include/multiplier/AST/TargetClonesAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class TargetClonesAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TargetClonesAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/TargetVersionAttr.h b/include/multiplier/AST/TargetVersionAttr.h
index f11dbb647..c4569361c 100644
--- a/include/multiplier/AST/TargetVersionAttr.h
+++ b/include/multiplier/AST/TargetVersionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class TargetVersionAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TargetVersionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/TemplateArgument.h b/include/multiplier/AST/TemplateArgument.h
index b61183960..b55824fbe 100644
--- a/include/multiplier/AST/TemplateArgument.h
+++ b/include/multiplier/AST/TemplateArgument.h
@@ -36,11 +36,6 @@ class TemplateArgumentImpl;
 class Token;
 class Type;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TemplateArgument {
  public:
@@ -59,8 +54,7 @@ class MX_EXPORT TemplateArgument {
   friend class TokenContext;
   friend class Type;
   friend class TemplateArgumentImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const TemplateArgumentImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
diff --git a/include/multiplier/AST/TemplateDecl.h b/include/multiplier/AST/TemplateDecl.h
index a65b88b70..4f53a07db 100644
--- a/include/multiplier/AST/TemplateDecl.h
+++ b/include/multiplier/AST/TemplateDecl.h
@@ -20,11 +20,6 @@ class Stmt;
 class TemplateDecl;
 class TemplateParameterList;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TemplateDecl : public NamedDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT TemplateDecl : public NamedDecl {
   static gap::generator<TemplateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TemplateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TemplateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TemplateDecl> in(const Compilation &tu);
   static gap::generator<TemplateDecl> containing(const Decl &decl);
   static gap::generator<TemplateDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/TemplateParamObjectDecl.h b/include/multiplier/AST/TemplateParamObjectDecl.h
index 95bd1da9d..91117fdf3 100644
--- a/include/multiplier/AST/TemplateParamObjectDecl.h
+++ b/include/multiplier/AST/TemplateParamObjectDecl.h
@@ -20,11 +20,6 @@ class Stmt;
 class TemplateParamObjectDecl;
 class Token;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TemplateParamObjectDecl : public ValueDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT TemplateParamObjectDecl : public ValueDecl {
   static gap::generator<TemplateParamObjectDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TemplateParamObjectDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TemplateParamObjectDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TemplateParamObjectDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::TEMPLATE_PARAM_OBJECT;
   }
diff --git a/include/multiplier/AST/TemplateParameterList.h b/include/multiplier/AST/TemplateParameterList.h
index aebee0506..bfce96374 100644
--- a/include/multiplier/AST/TemplateParameterList.h
+++ b/include/multiplier/AST/TemplateParameterList.h
@@ -35,11 +35,6 @@ class TemplateParameterList;
 class TemplateParameterListImpl;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TemplateParameterList {
  public:
@@ -57,8 +52,7 @@ class MX_EXPORT TemplateParameterList {
   friend class TokenContext;
   friend class Type;
   friend class TemplateParameterListImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const TemplateParameterListImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
diff --git a/include/multiplier/AST/TemplateSpecializationType.h b/include/multiplier/AST/TemplateSpecializationType.h
index 5d2bc0b6f..f6c06f0fb 100644
--- a/include/multiplier/AST/TemplateSpecializationType.h
+++ b/include/multiplier/AST/TemplateSpecializationType.h
@@ -17,11 +17,6 @@ class TemplateArgument;
 class TemplateSpecializationType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TemplateSpecializationType : public Type {
  private:
diff --git a/include/multiplier/AST/TemplateTemplateParmDecl.h b/include/multiplier/AST/TemplateTemplateParmDecl.h
index 9961f0eda..7ba426c48 100644
--- a/include/multiplier/AST/TemplateTemplateParmDecl.h
+++ b/include/multiplier/AST/TemplateTemplateParmDecl.h
@@ -20,11 +20,6 @@ class Stmt;
 class TemplateDecl;
 class TemplateTemplateParmDecl;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TemplateTemplateParmDecl : public TemplateDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT TemplateTemplateParmDecl : public TemplateDecl {
   static gap::generator<TemplateTemplateParmDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TemplateTemplateParmDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TemplateTemplateParmDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TemplateTemplateParmDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::TEMPLATE_TEMPLATE_PARM;
   }
diff --git a/include/multiplier/AST/TemplateTypeParmDecl.h b/include/multiplier/AST/TemplateTypeParmDecl.h
index add9e4627..edb24f71d 100644
--- a/include/multiplier/AST/TemplateTypeParmDecl.h
+++ b/include/multiplier/AST/TemplateTypeParmDecl.h
@@ -21,11 +21,6 @@ class TemplateTypeParmDecl;
 class Token;
 class Type;
 class TypeDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TemplateTypeParmDecl : public TypeDecl {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT TemplateTypeParmDecl : public TypeDecl {
   static gap::generator<TemplateTypeParmDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TemplateTypeParmDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TemplateTypeParmDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TemplateTypeParmDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::TEMPLATE_TYPE_PARM;
   }
diff --git a/include/multiplier/AST/TemplateTypeParmType.h b/include/multiplier/AST/TemplateTypeParmType.h
index ecb3c45e5..c008ca987 100644
--- a/include/multiplier/AST/TemplateTypeParmType.h
+++ b/include/multiplier/AST/TemplateTypeParmType.h
@@ -17,11 +17,6 @@ class TemplateTypeParmDecl;
 class TemplateTypeParmType;
 class Token;
 class Type;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TemplateTypeParmType : public Type {
  private:
diff --git a/include/multiplier/AST/TestTypestateAttr.h b/include/multiplier/AST/TestTypestateAttr.h
index 10f6b8766..8147696ff 100644
--- a/include/multiplier/AST/TestTypestateAttr.h
+++ b/include/multiplier/AST/TestTypestateAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class TestTypestateAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TestTypestateAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ThisCallAttr.h b/include/multiplier/AST/ThisCallAttr.h
index bab34a2b6..60cb30e9a 100644
--- a/include/multiplier/AST/ThisCallAttr.h
+++ b/include/multiplier/AST/ThisCallAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class ThisCallAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ThisCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ThreadAttr.h b/include/multiplier/AST/ThreadAttr.h
index 152d18e46..d8ae75c90 100644
--- a/include/multiplier/AST/ThreadAttr.h
+++ b/include/multiplier/AST/ThreadAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class ThreadAttr;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ThreadAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/TopLevelStmtDecl.h b/include/multiplier/AST/TopLevelStmtDecl.h
index b6525a0ea..2652d1c5d 100644
--- a/include/multiplier/AST/TopLevelStmtDecl.h
+++ b/include/multiplier/AST/TopLevelStmtDecl.h
@@ -18,11 +18,6 @@ class File;
 class Stmt;
 class Token;
 class TopLevelStmtDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TopLevelStmtDecl : public Decl {
  private:
@@ -35,8 +30,7 @@ class MX_EXPORT TopLevelStmtDecl : public Decl {
   static gap::generator<TopLevelStmtDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TopLevelStmtDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TopLevelStmtDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TopLevelStmtDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::TOP_LEVEL_STMT;
   }
diff --git a/include/multiplier/AST/TranslationUnitDecl.h b/include/multiplier/AST/TranslationUnitDecl.h
index b9f54b71f..7d05bdf7a 100644
--- a/include/multiplier/AST/TranslationUnitDecl.h
+++ b/include/multiplier/AST/TranslationUnitDecl.h
@@ -19,11 +19,6 @@ class File;
 class Stmt;
 class Token;
 class TranslationUnitDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TranslationUnitDecl : public Decl {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT TranslationUnitDecl : public Decl {
   static gap::generator<TranslationUnitDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TranslationUnitDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TranslationUnitDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TranslationUnitDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::TRANSLATION_UNIT;
   }
diff --git a/include/multiplier/AST/TransparentUnionAttr.h b/include/multiplier/AST/TransparentUnionAttr.h
index c7ae6c880..7cfdb269e 100644
--- a/include/multiplier/AST/TransparentUnionAttr.h
+++ b/include/multiplier/AST/TransparentUnionAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class TransparentUnionAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TransparentUnionAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/TrivialABIAttr.h b/include/multiplier/AST/TrivialABIAttr.h
index a454c0ebb..9f47ca5cd 100644
--- a/include/multiplier/AST/TrivialABIAttr.h
+++ b/include/multiplier/AST/TrivialABIAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class TrivialABIAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TrivialABIAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/TryAcquireCapabilityAttr.h b/include/multiplier/AST/TryAcquireCapabilityAttr.h
index 1989cd6ca..8a3da9d3d 100644
--- a/include/multiplier/AST/TryAcquireCapabilityAttr.h
+++ b/include/multiplier/AST/TryAcquireCapabilityAttr.h
@@ -20,11 +20,6 @@ class File;
 class InheritableAttr;
 class Token;
 class TryAcquireCapabilityAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TryAcquireCapabilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/Type.h b/include/multiplier/AST/Type.h
index e5fd13625..377e23751 100644
--- a/include/multiplier/AST/Type.h
+++ b/include/multiplier/AST/Type.h
@@ -35,11 +35,6 @@ class Token;
 class TokenRange;
 class Type;
 class TypeImpl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT Type {
  public:
@@ -55,8 +50,7 @@ class MX_EXPORT Type {
   friend class Stmt;
   friend class TokenContext;
   friend class TypeImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const TypeImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
diff --git a/include/multiplier/AST/TypeAliasDecl.h b/include/multiplier/AST/TypeAliasDecl.h
index b097b19b9..3c26b2823 100644
--- a/include/multiplier/AST/TypeAliasDecl.h
+++ b/include/multiplier/AST/TypeAliasDecl.h
@@ -22,11 +22,6 @@ class TypeAliasDecl;
 class TypeAliasTemplateDecl;
 class TypeDecl;
 class TypedefNameDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeAliasDecl : public TypedefNameDecl {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT TypeAliasDecl : public TypedefNameDecl {
   static gap::generator<TypeAliasDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TypeAliasDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TypeAliasDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TypeAliasDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::TYPE_ALIAS;
   }
diff --git a/include/multiplier/AST/TypeAliasTemplateDecl.h b/include/multiplier/AST/TypeAliasTemplateDecl.h
index bb6ad629c..ada0fd93d 100644
--- a/include/multiplier/AST/TypeAliasTemplateDecl.h
+++ b/include/multiplier/AST/TypeAliasTemplateDecl.h
@@ -21,11 +21,6 @@ class Stmt;
 class TemplateDecl;
 class Token;
 class TypeAliasTemplateDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeAliasTemplateDecl : public RedeclarableTemplateDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT TypeAliasTemplateDecl : public RedeclarableTemplateDecl {
   static gap::generator<TypeAliasTemplateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TypeAliasTemplateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TypeAliasTemplateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TypeAliasTemplateDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::TYPE_ALIAS_TEMPLATE;
   }
diff --git a/include/multiplier/AST/TypeAttr.h b/include/multiplier/AST/TypeAttr.h
index fdcc85ba6..3c286a5a9 100644
--- a/include/multiplier/AST/TypeAttr.h
+++ b/include/multiplier/AST/TypeAttr.h
@@ -17,11 +17,6 @@ class Attr;
 class File;
 class Token;
 class TypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeAttr : public Attr {
  private:
diff --git a/include/multiplier/AST/TypeDecl.h b/include/multiplier/AST/TypeDecl.h
index 56e4cc061..e757bb63d 100644
--- a/include/multiplier/AST/TypeDecl.h
+++ b/include/multiplier/AST/TypeDecl.h
@@ -20,11 +20,6 @@ class Stmt;
 class Token;
 class Type;
 class TypeDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeDecl : public NamedDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT TypeDecl : public NamedDecl {
   static gap::generator<TypeDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TypeDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TypeDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TypeDecl> in(const Compilation &tu);
   static gap::generator<TypeDecl> containing(const Decl &decl);
   static gap::generator<TypeDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/TypeNonNullAttr.h b/include/multiplier/AST/TypeNonNullAttr.h
index 91bdf38d3..47eebbbb0 100644
--- a/include/multiplier/AST/TypeNonNullAttr.h
+++ b/include/multiplier/AST/TypeNonNullAttr.h
@@ -18,11 +18,6 @@ class File;
 class Token;
 class TypeAttr;
 class TypeNonNullAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeNonNullAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/TypeNullUnspecifiedAttr.h b/include/multiplier/AST/TypeNullUnspecifiedAttr.h
index b22d40c34..791823064 100644
--- a/include/multiplier/AST/TypeNullUnspecifiedAttr.h
+++ b/include/multiplier/AST/TypeNullUnspecifiedAttr.h
@@ -18,11 +18,6 @@ class File;
 class Token;
 class TypeAttr;
 class TypeNullUnspecifiedAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeNullUnspecifiedAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/TypeNullableAttr.h b/include/multiplier/AST/TypeNullableAttr.h
index 137c80230..ead5387f7 100644
--- a/include/multiplier/AST/TypeNullableAttr.h
+++ b/include/multiplier/AST/TypeNullableAttr.h
@@ -18,11 +18,6 @@ class File;
 class Token;
 class TypeAttr;
 class TypeNullableAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeNullableAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/TypeNullableResultAttr.h b/include/multiplier/AST/TypeNullableResultAttr.h
index 5f040906b..45ebc118a 100644
--- a/include/multiplier/AST/TypeNullableResultAttr.h
+++ b/include/multiplier/AST/TypeNullableResultAttr.h
@@ -18,11 +18,6 @@ class File;
 class Token;
 class TypeAttr;
 class TypeNullableResultAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeNullableResultAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/TypeOfExprType.h b/include/multiplier/AST/TypeOfExprType.h
index ca2ad3ac8..f5ef15178 100644
--- a/include/multiplier/AST/TypeOfExprType.h
+++ b/include/multiplier/AST/TypeOfExprType.h
@@ -18,11 +18,6 @@ class Expr;
 class Token;
 class Type;
 class TypeOfExprType;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeOfExprType : public Type {
  private:
diff --git a/include/multiplier/AST/TypeOfType.h b/include/multiplier/AST/TypeOfType.h
index 4bee99684..466b64c96 100644
--- a/include/multiplier/AST/TypeOfType.h
+++ b/include/multiplier/AST/TypeOfType.h
@@ -17,11 +17,6 @@ class Index;
 class Token;
 class Type;
 class TypeOfType;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeOfType : public Type {
  private:
diff --git a/include/multiplier/AST/TypeTagForDatatypeAttr.h b/include/multiplier/AST/TypeTagForDatatypeAttr.h
index c33699d73..07dbe0991 100644
--- a/include/multiplier/AST/TypeTagForDatatypeAttr.h
+++ b/include/multiplier/AST/TypeTagForDatatypeAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class Token;
 class Type;
 class TypeTagForDatatypeAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeTagForDatatypeAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/TypeTraitExpr.h b/include/multiplier/AST/TypeTraitExpr.h
index b2582bc86..efee9c87c 100644
--- a/include/multiplier/AST/TypeTraitExpr.h
+++ b/include/multiplier/AST/TypeTraitExpr.h
@@ -22,11 +22,6 @@ class Token;
 class Type;
 class TypeTraitExpr;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeTraitExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT TypeTraitExpr : public Expr {
   static gap::generator<TypeTraitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TypeTraitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<TypeTraitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TypeTraitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::TYPE_TRAIT_EXPR;
   }
diff --git a/include/multiplier/AST/TypeVisibilityAttr.h b/include/multiplier/AST/TypeVisibilityAttr.h
index 347047531..4a5b95f24 100644
--- a/include/multiplier/AST/TypeVisibilityAttr.h
+++ b/include/multiplier/AST/TypeVisibilityAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class Token;
 class TypeVisibilityAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeVisibilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/TypeWithKeyword.h b/include/multiplier/AST/TypeWithKeyword.h
index 2ac1d447c..bf6338e8d 100644
--- a/include/multiplier/AST/TypeWithKeyword.h
+++ b/include/multiplier/AST/TypeWithKeyword.h
@@ -17,11 +17,6 @@ class Index;
 class Token;
 class Type;
 class TypeWithKeyword;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypeWithKeyword : public Type {
  private:
diff --git a/include/multiplier/AST/TypedefDecl.h b/include/multiplier/AST/TypedefDecl.h
index 9dc881798..1634fc630 100644
--- a/include/multiplier/AST/TypedefDecl.h
+++ b/include/multiplier/AST/TypedefDecl.h
@@ -21,11 +21,6 @@ class Token;
 class TypeDecl;
 class TypedefDecl;
 class TypedefNameDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypedefDecl : public TypedefNameDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT TypedefDecl : public TypedefNameDecl {
   static gap::generator<TypedefDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TypedefDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TypedefDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TypedefDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::TYPEDEF;
   }
diff --git a/include/multiplier/AST/TypedefNameDecl.h b/include/multiplier/AST/TypedefNameDecl.h
index 30f5ff539..e2cad5a34 100644
--- a/include/multiplier/AST/TypedefNameDecl.h
+++ b/include/multiplier/AST/TypedefNameDecl.h
@@ -22,11 +22,6 @@ class Token;
 class Type;
 class TypeDecl;
 class TypedefNameDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypedefNameDecl : public TypeDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT TypedefNameDecl : public TypeDecl {
   static gap::generator<TypedefNameDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TypedefNameDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<TypedefNameDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TypedefNameDecl> in(const Compilation &tu);
   static gap::generator<TypedefNameDecl> containing(const Decl &decl);
   static gap::generator<TypedefNameDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/TypedefType.h b/include/multiplier/AST/TypedefType.h
index 5cef32e67..a85c518ca 100644
--- a/include/multiplier/AST/TypedefType.h
+++ b/include/multiplier/AST/TypedefType.h
@@ -17,11 +17,6 @@ class Token;
 class Type;
 class TypedefNameDecl;
 class TypedefType;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypedefType : public Type {
  private:
diff --git a/include/multiplier/AST/TypoExpr.h b/include/multiplier/AST/TypoExpr.h
index 944c1f9db..cbae3708c 100644
--- a/include/multiplier/AST/TypoExpr.h
+++ b/include/multiplier/AST/TypoExpr.h
@@ -20,11 +20,6 @@ class Stmt;
 class Token;
 class TypoExpr;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT TypoExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT TypoExpr : public Expr {
   static gap::generator<TypoExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<TypoExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<TypoExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<TypoExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::TYPO_EXPR;
   }
diff --git a/include/multiplier/AST/UPtrAttr.h b/include/multiplier/AST/UPtrAttr.h
index 70ec8d063..141ba7b07 100644
--- a/include/multiplier/AST/UPtrAttr.h
+++ b/include/multiplier/AST/UPtrAttr.h
@@ -18,11 +18,6 @@ class File;
 class Token;
 class TypeAttr;
 class UPtrAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UPtrAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/UnaryExprOrTypeTraitExpr.h b/include/multiplier/AST/UnaryExprOrTypeTraitExpr.h
index 0f8dc4dc5..5f88fb6fa 100644
--- a/include/multiplier/AST/UnaryExprOrTypeTraitExpr.h
+++ b/include/multiplier/AST/UnaryExprOrTypeTraitExpr.h
@@ -22,11 +22,6 @@ class Token;
 class Type;
 class UnaryExprOrTypeTraitExpr;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnaryExprOrTypeTraitExpr : public Expr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT UnaryExprOrTypeTraitExpr : public Expr {
   static gap::generator<UnaryExprOrTypeTraitExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UnaryExprOrTypeTraitExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<UnaryExprOrTypeTraitExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UnaryExprOrTypeTraitExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::UNARY_EXPR_OR_TYPE_TRAIT_EXPR;
   }
diff --git a/include/multiplier/AST/UnaryOperator.h b/include/multiplier/AST/UnaryOperator.h
index 26a02c3a4..6a3a5825f 100644
--- a/include/multiplier/AST/UnaryOperator.h
+++ b/include/multiplier/AST/UnaryOperator.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class UnaryOperator;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnaryOperator : public Expr {
  private:
@@ -40,8 +35,7 @@ class MX_EXPORT UnaryOperator : public Expr {
   static gap::generator<UnaryOperator> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UnaryOperator> from(const ir::Operation &op);
-  static gap::generator<std::pair<UnaryOperator, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UnaryOperator> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::UNARY_OPERATOR;
   }
diff --git a/include/multiplier/AST/UnaryTransformType.h b/include/multiplier/AST/UnaryTransformType.h
index 61e513b40..dc92db0d0 100644
--- a/include/multiplier/AST/UnaryTransformType.h
+++ b/include/multiplier/AST/UnaryTransformType.h
@@ -17,11 +17,6 @@ class Index;
 class Token;
 class Type;
 class UnaryTransformType;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnaryTransformType : public Type {
  private:
diff --git a/include/multiplier/AST/UnavailableAttr.h b/include/multiplier/AST/UnavailableAttr.h
index dd9ceefb7..2f1d73f7b 100644
--- a/include/multiplier/AST/UnavailableAttr.h
+++ b/include/multiplier/AST/UnavailableAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class Token;
 class UnavailableAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnavailableAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/UninitializedAttr.h b/include/multiplier/AST/UninitializedAttr.h
index 00d9328ca..e2aa8c7e2 100644
--- a/include/multiplier/AST/UninitializedAttr.h
+++ b/include/multiplier/AST/UninitializedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class UninitializedAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UninitializedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/UnlikelyAttr.h b/include/multiplier/AST/UnlikelyAttr.h
index 1311b89ca..87fa33cb1 100644
--- a/include/multiplier/AST/UnlikelyAttr.h
+++ b/include/multiplier/AST/UnlikelyAttr.h
@@ -18,11 +18,6 @@ class File;
 class StmtAttr;
 class Token;
 class UnlikelyAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnlikelyAttr : public StmtAttr {
  private:
diff --git a/include/multiplier/AST/UnnamedGlobalConstantDecl.h b/include/multiplier/AST/UnnamedGlobalConstantDecl.h
index d50e6e2af..c50f9ac6f 100644
--- a/include/multiplier/AST/UnnamedGlobalConstantDecl.h
+++ b/include/multiplier/AST/UnnamedGlobalConstantDecl.h
@@ -20,11 +20,6 @@ class Stmt;
 class Token;
 class UnnamedGlobalConstantDecl;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnnamedGlobalConstantDecl : public ValueDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT UnnamedGlobalConstantDecl : public ValueDecl {
   static gap::generator<UnnamedGlobalConstantDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UnnamedGlobalConstantDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<UnnamedGlobalConstantDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UnnamedGlobalConstantDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::UNNAMED_GLOBAL_CONSTANT;
   }
diff --git a/include/multiplier/AST/UnresolvedLookupExpr.h b/include/multiplier/AST/UnresolvedLookupExpr.h
index eb6b6da37..24eb8f505 100644
--- a/include/multiplier/AST/UnresolvedLookupExpr.h
+++ b/include/multiplier/AST/UnresolvedLookupExpr.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class UnresolvedLookupExpr;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnresolvedLookupExpr : public OverloadExpr {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT UnresolvedLookupExpr : public OverloadExpr {
   static gap::generator<UnresolvedLookupExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UnresolvedLookupExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<UnresolvedLookupExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UnresolvedLookupExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::UNRESOLVED_LOOKUP_EXPR;
   }
diff --git a/include/multiplier/AST/UnresolvedMemberExpr.h b/include/multiplier/AST/UnresolvedMemberExpr.h
index b3b1984df..21aa236c7 100644
--- a/include/multiplier/AST/UnresolvedMemberExpr.h
+++ b/include/multiplier/AST/UnresolvedMemberExpr.h
@@ -22,11 +22,6 @@ class Token;
 class Type;
 class UnresolvedMemberExpr;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnresolvedMemberExpr : public OverloadExpr {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT UnresolvedMemberExpr : public OverloadExpr {
   static gap::generator<UnresolvedMemberExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UnresolvedMemberExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<UnresolvedMemberExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UnresolvedMemberExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::UNRESOLVED_MEMBER_EXPR;
   }
diff --git a/include/multiplier/AST/UnresolvedUsingIfExistsDecl.h b/include/multiplier/AST/UnresolvedUsingIfExistsDecl.h
index 98e57f90c..5bbf65572 100644
--- a/include/multiplier/AST/UnresolvedUsingIfExistsDecl.h
+++ b/include/multiplier/AST/UnresolvedUsingIfExistsDecl.h
@@ -19,11 +19,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class UnresolvedUsingIfExistsDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnresolvedUsingIfExistsDecl : public NamedDecl {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT UnresolvedUsingIfExistsDecl : public NamedDecl {
   static gap::generator<UnresolvedUsingIfExistsDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UnresolvedUsingIfExistsDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<UnresolvedUsingIfExistsDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UnresolvedUsingIfExistsDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::UNRESOLVED_USING_IF_EXISTS;
   }
diff --git a/include/multiplier/AST/UnresolvedUsingType.h b/include/multiplier/AST/UnresolvedUsingType.h
index fb7d60a2c..18cacfc9e 100644
--- a/include/multiplier/AST/UnresolvedUsingType.h
+++ b/include/multiplier/AST/UnresolvedUsingType.h
@@ -17,11 +17,6 @@ class Token;
 class Type;
 class UnresolvedUsingType;
 class UnresolvedUsingTypenameDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnresolvedUsingType : public Type {
  private:
diff --git a/include/multiplier/AST/UnresolvedUsingTypenameDecl.h b/include/multiplier/AST/UnresolvedUsingTypenameDecl.h
index f0d8f7246..5634aba3f 100644
--- a/include/multiplier/AST/UnresolvedUsingTypenameDecl.h
+++ b/include/multiplier/AST/UnresolvedUsingTypenameDecl.h
@@ -20,11 +20,6 @@ class Stmt;
 class Token;
 class TypeDecl;
 class UnresolvedUsingTypenameDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnresolvedUsingTypenameDecl : public TypeDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT UnresolvedUsingTypenameDecl : public TypeDecl {
   static gap::generator<UnresolvedUsingTypenameDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UnresolvedUsingTypenameDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<UnresolvedUsingTypenameDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UnresolvedUsingTypenameDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::UNRESOLVED_USING_TYPENAME;
   }
diff --git a/include/multiplier/AST/UnresolvedUsingValueDecl.h b/include/multiplier/AST/UnresolvedUsingValueDecl.h
index 225753e86..ef4ad24d0 100644
--- a/include/multiplier/AST/UnresolvedUsingValueDecl.h
+++ b/include/multiplier/AST/UnresolvedUsingValueDecl.h
@@ -20,11 +20,6 @@ class Stmt;
 class Token;
 class UnresolvedUsingValueDecl;
 class ValueDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnresolvedUsingValueDecl : public ValueDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT UnresolvedUsingValueDecl : public ValueDecl {
   static gap::generator<UnresolvedUsingValueDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UnresolvedUsingValueDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<UnresolvedUsingValueDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UnresolvedUsingValueDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::UNRESOLVED_USING_VALUE;
   }
diff --git a/include/multiplier/AST/UnsafeBufferUsageAttr.h b/include/multiplier/AST/UnsafeBufferUsageAttr.h
index 6dd468523..bb6fdf31a 100644
--- a/include/multiplier/AST/UnsafeBufferUsageAttr.h
+++ b/include/multiplier/AST/UnsafeBufferUsageAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class UnsafeBufferUsageAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnsafeBufferUsageAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/UnusedAttr.h b/include/multiplier/AST/UnusedAttr.h
index dc23df893..4d1998442 100644
--- a/include/multiplier/AST/UnusedAttr.h
+++ b/include/multiplier/AST/UnusedAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class Token;
 class UnusedAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UnusedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/UseHandleAttr.h b/include/multiplier/AST/UseHandleAttr.h
index f41bafd8a..296aaf886 100644
--- a/include/multiplier/AST/UseHandleAttr.h
+++ b/include/multiplier/AST/UseHandleAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class InheritableParamAttr;
 class Token;
 class UseHandleAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UseHandleAttr : public InheritableParamAttr {
  private:
diff --git a/include/multiplier/AST/UsedAttr.h b/include/multiplier/AST/UsedAttr.h
index 22a515e50..8cc8b1a12 100644
--- a/include/multiplier/AST/UsedAttr.h
+++ b/include/multiplier/AST/UsedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class UsedAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UsedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/UserDefinedLiteral.h b/include/multiplier/AST/UserDefinedLiteral.h
index 45469843e..8e1157b26 100644
--- a/include/multiplier/AST/UserDefinedLiteral.h
+++ b/include/multiplier/AST/UserDefinedLiteral.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class UserDefinedLiteral;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UserDefinedLiteral : public CallExpr {
  private:
@@ -42,8 +37,7 @@ class MX_EXPORT UserDefinedLiteral : public CallExpr {
   static gap::generator<UserDefinedLiteral> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UserDefinedLiteral> from(const ir::Operation &op);
-  static gap::generator<std::pair<UserDefinedLiteral, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UserDefinedLiteral> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::USER_DEFINED_LITERAL;
   }
diff --git a/include/multiplier/AST/UsingDecl.h b/include/multiplier/AST/UsingDecl.h
index a45a4f085..4c399a778 100644
--- a/include/multiplier/AST/UsingDecl.h
+++ b/include/multiplier/AST/UsingDecl.h
@@ -20,11 +20,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class UsingDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UsingDecl : public BaseUsingDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT UsingDecl : public BaseUsingDecl {
   static gap::generator<UsingDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UsingDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<UsingDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UsingDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::USING;
   }
diff --git a/include/multiplier/AST/UsingDirectiveDecl.h b/include/multiplier/AST/UsingDirectiveDecl.h
index bb2e2db34..851ba2db7 100644
--- a/include/multiplier/AST/UsingDirectiveDecl.h
+++ b/include/multiplier/AST/UsingDirectiveDecl.h
@@ -20,11 +20,6 @@ class NamespaceDecl;
 class Stmt;
 class Token;
 class UsingDirectiveDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UsingDirectiveDecl : public NamedDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT UsingDirectiveDecl : public NamedDecl {
   static gap::generator<UsingDirectiveDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UsingDirectiveDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<UsingDirectiveDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UsingDirectiveDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::USING_DIRECTIVE;
   }
diff --git a/include/multiplier/AST/UsingEnumDecl.h b/include/multiplier/AST/UsingEnumDecl.h
index 36bf457aa..aba221432 100644
--- a/include/multiplier/AST/UsingEnumDecl.h
+++ b/include/multiplier/AST/UsingEnumDecl.h
@@ -22,11 +22,6 @@ class Stmt;
 class Token;
 class Type;
 class UsingEnumDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UsingEnumDecl : public BaseUsingDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT UsingEnumDecl : public BaseUsingDecl {
   static gap::generator<UsingEnumDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UsingEnumDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<UsingEnumDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UsingEnumDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::USING_ENUM;
   }
diff --git a/include/multiplier/AST/UsingIfExistsAttr.h b/include/multiplier/AST/UsingIfExistsAttr.h
index 272b7634f..770daf9f5 100644
--- a/include/multiplier/AST/UsingIfExistsAttr.h
+++ b/include/multiplier/AST/UsingIfExistsAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class UsingIfExistsAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UsingIfExistsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/UsingPackDecl.h b/include/multiplier/AST/UsingPackDecl.h
index 07d9121b8..c99a10b6f 100644
--- a/include/multiplier/AST/UsingPackDecl.h
+++ b/include/multiplier/AST/UsingPackDecl.h
@@ -19,11 +19,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class UsingPackDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UsingPackDecl : public NamedDecl {
  private:
@@ -37,8 +32,7 @@ class MX_EXPORT UsingPackDecl : public NamedDecl {
   static gap::generator<UsingPackDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UsingPackDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<UsingPackDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UsingPackDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::USING_PACK;
   }
diff --git a/include/multiplier/AST/UsingShadowDecl.h b/include/multiplier/AST/UsingShadowDecl.h
index f2469f42f..97b9379bd 100644
--- a/include/multiplier/AST/UsingShadowDecl.h
+++ b/include/multiplier/AST/UsingShadowDecl.h
@@ -20,11 +20,6 @@ class NamedDecl;
 class Stmt;
 class Token;
 class UsingShadowDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UsingShadowDecl : public NamedDecl {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT UsingShadowDecl : public NamedDecl {
   static gap::generator<UsingShadowDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<UsingShadowDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<UsingShadowDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<UsingShadowDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::USING_SHADOW;
   }
diff --git a/include/multiplier/AST/UsingType.h b/include/multiplier/AST/UsingType.h
index f117975c6..51bf04b1d 100644
--- a/include/multiplier/AST/UsingType.h
+++ b/include/multiplier/AST/UsingType.h
@@ -17,11 +17,6 @@ class Token;
 class Type;
 class UsingShadowDecl;
 class UsingType;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UsingType : public Type {
  private:
diff --git a/include/multiplier/AST/UuidAttr.h b/include/multiplier/AST/UuidAttr.h
index eb477a0b3..0d00b20ea 100644
--- a/include/multiplier/AST/UuidAttr.h
+++ b/include/multiplier/AST/UuidAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class MSGuidDecl;
 class Token;
 class UuidAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UuidAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/VAArgExpr.h b/include/multiplier/AST/VAArgExpr.h
index a7ac92623..2b82c2138 100644
--- a/include/multiplier/AST/VAArgExpr.h
+++ b/include/multiplier/AST/VAArgExpr.h
@@ -20,11 +20,6 @@ class Stmt;
 class Token;
 class VAArgExpr;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VAArgExpr : public Expr {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT VAArgExpr : public Expr {
   static gap::generator<VAArgExpr> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<VAArgExpr> from(const ir::Operation &op);
-  static gap::generator<std::pair<VAArgExpr, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<VAArgExpr> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::VA_ARG_EXPR;
   }
diff --git a/include/multiplier/AST/ValueDecl.h b/include/multiplier/AST/ValueDecl.h
index 5d4a8780d..4e98913a7 100644
--- a/include/multiplier/AST/ValueDecl.h
+++ b/include/multiplier/AST/ValueDecl.h
@@ -21,11 +21,6 @@ class Token;
 class Type;
 class ValueDecl;
 class VarDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ValueDecl : public NamedDecl {
  private:
@@ -39,8 +34,7 @@ class MX_EXPORT ValueDecl : public NamedDecl {
   static gap::generator<ValueDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ValueDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<ValueDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ValueDecl> in(const Compilation &tu);
   static gap::generator<ValueDecl> containing(const Decl &decl);
   static gap::generator<ValueDecl> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/ValueStmt.h b/include/multiplier/AST/ValueStmt.h
index ae4d2363f..6b65b1269 100644
--- a/include/multiplier/AST/ValueStmt.h
+++ b/include/multiplier/AST/ValueStmt.h
@@ -19,11 +19,6 @@ class File;
 class Stmt;
 class Token;
 class ValueStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ValueStmt : public Stmt {
  private:
@@ -36,8 +31,7 @@ class MX_EXPORT ValueStmt : public Stmt {
   static gap::generator<ValueStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<ValueStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<ValueStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<ValueStmt> in(const Compilation &tu);
   static gap::generator<ValueStmt> containing(const Decl &decl);
   static gap::generator<ValueStmt> containing(const std::optional<Decl> &decl);
 
diff --git a/include/multiplier/AST/VarDecl.h b/include/multiplier/AST/VarDecl.h
index 4b12b7ae5..dffd3cc72 100644
--- a/include/multiplier/AST/VarDecl.h
+++ b/include/multiplier/AST/VarDecl.h
@@ -29,11 +29,6 @@ class Token;
 class ValueDecl;
 class VarDecl;
 class VarTemplateDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VarDecl : public DeclaratorDecl {
  private:
@@ -49,8 +44,7 @@ class MX_EXPORT VarDecl : public DeclaratorDecl {
   static gap::generator<VarDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<VarDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<VarDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<VarDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::VAR;
   }
diff --git a/include/multiplier/AST/VarTemplateDecl.h b/include/multiplier/AST/VarTemplateDecl.h
index 12cb0afc6..f6610cdc0 100644
--- a/include/multiplier/AST/VarTemplateDecl.h
+++ b/include/multiplier/AST/VarTemplateDecl.h
@@ -21,11 +21,6 @@ class Stmt;
 class TemplateDecl;
 class Token;
 class VarTemplateDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VarTemplateDecl : public RedeclarableTemplateDecl {
  private:
@@ -41,8 +36,7 @@ class MX_EXPORT VarTemplateDecl : public RedeclarableTemplateDecl {
   static gap::generator<VarTemplateDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<VarTemplateDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<VarTemplateDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<VarTemplateDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::VAR_TEMPLATE;
   }
diff --git a/include/multiplier/AST/VarTemplatePartialSpecializationDecl.h b/include/multiplier/AST/VarTemplatePartialSpecializationDecl.h
index 4dedbd76b..e3181ffe9 100644
--- a/include/multiplier/AST/VarTemplatePartialSpecializationDecl.h
+++ b/include/multiplier/AST/VarTemplatePartialSpecializationDecl.h
@@ -24,11 +24,6 @@ class ValueDecl;
 class VarDecl;
 class VarTemplatePartialSpecializationDecl;
 class VarTemplateSpecializationDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VarTemplatePartialSpecializationDecl : public VarTemplateSpecializationDecl {
  private:
@@ -46,8 +41,7 @@ class MX_EXPORT VarTemplatePartialSpecializationDecl : public VarTemplateSpecial
   static gap::generator<VarTemplatePartialSpecializationDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<VarTemplatePartialSpecializationDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<VarTemplatePartialSpecializationDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<VarTemplatePartialSpecializationDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::VAR_TEMPLATE_PARTIAL_SPECIALIZATION;
   }
diff --git a/include/multiplier/AST/VarTemplateSpecializationDecl.h b/include/multiplier/AST/VarTemplateSpecializationDecl.h
index d67febac6..61db9f6b8 100644
--- a/include/multiplier/AST/VarTemplateSpecializationDecl.h
+++ b/include/multiplier/AST/VarTemplateSpecializationDecl.h
@@ -25,11 +25,6 @@ class ValueDecl;
 class VarDecl;
 class VarTemplateDecl;
 class VarTemplateSpecializationDecl;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VarTemplateSpecializationDecl : public VarDecl {
  private:
@@ -46,8 +41,7 @@ class MX_EXPORT VarTemplateSpecializationDecl : public VarDecl {
   static gap::generator<VarTemplateSpecializationDecl> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<VarTemplateSpecializationDecl> from(const ir::Operation &op);
-  static gap::generator<std::pair<VarTemplateSpecializationDecl, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<VarTemplateSpecializationDecl> in(const Compilation &tu);
   inline static constexpr DeclKind static_kind(void) {
     return DeclKind::VAR_TEMPLATE_SPECIALIZATION;
   }
diff --git a/include/multiplier/AST/VariableArrayType.h b/include/multiplier/AST/VariableArrayType.h
index d9f459826..ad40c7e9c 100644
--- a/include/multiplier/AST/VariableArrayType.h
+++ b/include/multiplier/AST/VariableArrayType.h
@@ -19,11 +19,6 @@ class Token;
 class TokenRange;
 class Type;
 class VariableArrayType;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VariableArrayType : public ArrayType {
  private:
diff --git a/include/multiplier/AST/VecReturnAttr.h b/include/multiplier/AST/VecReturnAttr.h
index 1c991d87f..83f071d2a 100644
--- a/include/multiplier/AST/VecReturnAttr.h
+++ b/include/multiplier/AST/VecReturnAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class VecReturnAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VecReturnAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/VecTypeHintAttr.h b/include/multiplier/AST/VecTypeHintAttr.h
index 8e56624f6..fc25d7054 100644
--- a/include/multiplier/AST/VecTypeHintAttr.h
+++ b/include/multiplier/AST/VecTypeHintAttr.h
@@ -19,11 +19,6 @@ class InheritableAttr;
 class Token;
 class Type;
 class VecTypeHintAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VecTypeHintAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/VectorCallAttr.h b/include/multiplier/AST/VectorCallAttr.h
index f95b23fe9..bd280c030 100644
--- a/include/multiplier/AST/VectorCallAttr.h
+++ b/include/multiplier/AST/VectorCallAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class VectorCallAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VectorCallAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/VectorType.h b/include/multiplier/AST/VectorType.h
index 46a99be30..90799c306 100644
--- a/include/multiplier/AST/VectorType.h
+++ b/include/multiplier/AST/VectorType.h
@@ -17,11 +17,6 @@ class Index;
 class Token;
 class Type;
 class VectorType;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VectorType : public Type {
  private:
diff --git a/include/multiplier/AST/VisibilityAttr.h b/include/multiplier/AST/VisibilityAttr.h
index 8ccb5c7b1..d3aca95c0 100644
--- a/include/multiplier/AST/VisibilityAttr.h
+++ b/include/multiplier/AST/VisibilityAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class Token;
 class VisibilityAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT VisibilityAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/WarnUnusedAttr.h b/include/multiplier/AST/WarnUnusedAttr.h
index 5c8afe93e..a3dbd64a7 100644
--- a/include/multiplier/AST/WarnUnusedAttr.h
+++ b/include/multiplier/AST/WarnUnusedAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class WarnUnusedAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WarnUnusedAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/WarnUnusedResultAttr.h b/include/multiplier/AST/WarnUnusedResultAttr.h
index 70ed813df..81bcc2132 100644
--- a/include/multiplier/AST/WarnUnusedResultAttr.h
+++ b/include/multiplier/AST/WarnUnusedResultAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class Token;
 class WarnUnusedResultAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WarnUnusedResultAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/WeakAttr.h b/include/multiplier/AST/WeakAttr.h
index 2739a98e5..96fd514d5 100644
--- a/include/multiplier/AST/WeakAttr.h
+++ b/include/multiplier/AST/WeakAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class WeakAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WeakAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/WeakImportAttr.h b/include/multiplier/AST/WeakImportAttr.h
index fbf74d224..34d48e152 100644
--- a/include/multiplier/AST/WeakImportAttr.h
+++ b/include/multiplier/AST/WeakImportAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class WeakImportAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WeakImportAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/WeakRefAttr.h b/include/multiplier/AST/WeakRefAttr.h
index fab3d7d2c..087a8510f 100644
--- a/include/multiplier/AST/WeakRefAttr.h
+++ b/include/multiplier/AST/WeakRefAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class WeakRefAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WeakRefAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/WebAssemblyExportNameAttr.h b/include/multiplier/AST/WebAssemblyExportNameAttr.h
index 6d393a50f..ea20d0bdd 100644
--- a/include/multiplier/AST/WebAssemblyExportNameAttr.h
+++ b/include/multiplier/AST/WebAssemblyExportNameAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class WebAssemblyExportNameAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WebAssemblyExportNameAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/WebAssemblyFuncrefAttr.h b/include/multiplier/AST/WebAssemblyFuncrefAttr.h
index 1d22fcc30..a0b79a407 100644
--- a/include/multiplier/AST/WebAssemblyFuncrefAttr.h
+++ b/include/multiplier/AST/WebAssemblyFuncrefAttr.h
@@ -18,11 +18,6 @@ class File;
 class Token;
 class TypeAttr;
 class WebAssemblyFuncrefAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WebAssemblyFuncrefAttr : public TypeAttr {
  private:
diff --git a/include/multiplier/AST/WebAssemblyImportModuleAttr.h b/include/multiplier/AST/WebAssemblyImportModuleAttr.h
index 48388bbe9..fd8a220c5 100644
--- a/include/multiplier/AST/WebAssemblyImportModuleAttr.h
+++ b/include/multiplier/AST/WebAssemblyImportModuleAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class WebAssemblyImportModuleAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WebAssemblyImportModuleAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/WebAssemblyImportNameAttr.h b/include/multiplier/AST/WebAssemblyImportNameAttr.h
index a12175d5f..113e15dd6 100644
--- a/include/multiplier/AST/WebAssemblyImportNameAttr.h
+++ b/include/multiplier/AST/WebAssemblyImportNameAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class WebAssemblyImportNameAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WebAssemblyImportNameAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/WhileStmt.h b/include/multiplier/AST/WhileStmt.h
index 538cfde54..bd9a57c69 100644
--- a/include/multiplier/AST/WhileStmt.h
+++ b/include/multiplier/AST/WhileStmt.h
@@ -21,11 +21,6 @@ class Stmt;
 class Token;
 class VarDecl;
 class WhileStmt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WhileStmt : public Stmt {
  private:
@@ -38,8 +33,7 @@ class MX_EXPORT WhileStmt : public Stmt {
   static gap::generator<WhileStmt> containing(const Token &tok);
   bool contains(const Token &tok) const;
 
-  static std::optional<WhileStmt> from(const ir::Operation &op);
-  static gap::generator<std::pair<WhileStmt, ir::Operation>> in(const Compilation &tu);
+  static gap::generator<WhileStmt> in(const Compilation &tu);
   inline static constexpr StmtKind static_kind(void) {
     return StmtKind::WHILE_STMT;
   }
diff --git a/include/multiplier/AST/WorkGroupSizeHintAttr.h b/include/multiplier/AST/WorkGroupSizeHintAttr.h
index d53c81292..1f79df9f1 100644
--- a/include/multiplier/AST/WorkGroupSizeHintAttr.h
+++ b/include/multiplier/AST/WorkGroupSizeHintAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class WorkGroupSizeHintAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT WorkGroupSizeHintAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/X86ForceAlignArgPointerAttr.h b/include/multiplier/AST/X86ForceAlignArgPointerAttr.h
index 2534d2570..c31cf7369 100644
--- a/include/multiplier/AST/X86ForceAlignArgPointerAttr.h
+++ b/include/multiplier/AST/X86ForceAlignArgPointerAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class X86ForceAlignArgPointerAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT X86ForceAlignArgPointerAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/XRayInstrumentAttr.h b/include/multiplier/AST/XRayInstrumentAttr.h
index b40ace58f..eb46db222 100644
--- a/include/multiplier/AST/XRayInstrumentAttr.h
+++ b/include/multiplier/AST/XRayInstrumentAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class Token;
 class XRayInstrumentAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT XRayInstrumentAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/XRayLogArgsAttr.h b/include/multiplier/AST/XRayLogArgsAttr.h
index 96048daf8..d7f4154b9 100644
--- a/include/multiplier/AST/XRayLogArgsAttr.h
+++ b/include/multiplier/AST/XRayLogArgsAttr.h
@@ -18,11 +18,6 @@ class File;
 class InheritableAttr;
 class Token;
 class XRayLogArgsAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT XRayLogArgsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/AST/ZeroCallUsedRegsAttr.h b/include/multiplier/AST/ZeroCallUsedRegsAttr.h
index 282c755f1..bad0f49b1 100644
--- a/include/multiplier/AST/ZeroCallUsedRegsAttr.h
+++ b/include/multiplier/AST/ZeroCallUsedRegsAttr.h
@@ -19,11 +19,6 @@ class File;
 class InheritableAttr;
 class Token;
 class ZeroCallUsedRegsAttr;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ZeroCallUsedRegsAttr : public InheritableAttr {
  private:
diff --git a/include/multiplier/Database.h b/include/multiplier/Database.h
index deb1ac1b0..094552338 100644
--- a/include/multiplier/Database.h
+++ b/include/multiplier/Database.h
@@ -435,8 +435,7 @@ struct TypeRecord {
 };
 
 // Records a compilation / translation unit into the database. A compilation
-// includes the MLIR generated by VAST for the translation unit. A compilation
-// also includes information about the compile command itself.
+// includes information about the compile command itself.
 struct CompilationRecord {
   static constexpr EntityCategory kCategory = EntityCategory::COMPILATION;
 
diff --git a/include/multiplier/Entity.h b/include/multiplier/Entity.h
index 17a027a72..b76de6935 100644
--- a/include/multiplier/Entity.h
+++ b/include/multiplier/Entity.h
@@ -8,9 +8,6 @@
 #include "Types.h"
 
 namespace mx {
-namespace ir {
-class Operation;
-}  // namespace ir
 
 class DefineMacroDirective;
 class NamedDecl;
@@ -31,8 +28,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_FORWARD_DECLARE,
                             MX_FORWARD_DECLARE,
                             MX_FORWARD_DECLARE,
                             MX_FORWARD_DECLARE,
-                            MX_FORWARD_DECLARE,
-                            MX_IGNORE_ENTITY_CATEGORY)
+                            MX_FORWARD_DECLARE)
 #undef MX_FORWARD_DECLARE
 
 #define MX_DECLARE_ENTITY_VARIANT(ns_path, type_name, lower_name, enum_name, category) \
@@ -46,7 +42,6 @@ using VariantEntity = std::variant<
                                             MX_DECLARE_ENTITY_VARIANT,
                                             MX_DECLARE_ENTITY_VARIANT,
                                             MX_DECLARE_ENTITY_VARIANT,
-                                            MX_DECLARE_ENTITY_VARIANT,
                                             MX_DECLARE_ENTITY_VARIANT)>;
 #undef MX_DECLARE_ENTITY_VARIANT
 
diff --git a/include/multiplier/Fragment.h b/include/multiplier/Fragment.h
index 741c1623e..122311802 100644
--- a/include/multiplier/Fragment.h
+++ b/include/multiplier/Fragment.h
@@ -15,9 +15,6 @@
 #include "Frontend/File.h"
 
 namespace mx {
-namespace ir {
-class Operation;
-}  // namespace ir
 
 class EntityProvider;
 class Index;
@@ -37,8 +34,7 @@ class RegexQueryMatch;
                               MX_FORWARD_DECLARE,
                               MX_FORWARD_DECLARE,
                               MX_FORWARD_DECLARE,
-                              MX_FORWARD_DECLARE,
-                              MX_IGNORE_ENTITY_CATEGORY)
+                              MX_FORWARD_DECLARE)
 #undef MX_FORWARD_DECLARE
 
 using PreprocessedEntity = std::variant<Macro, Token, Fragment>;
@@ -69,7 +65,6 @@ class MX_EXPORT Fragment {
                               MX_FRIEND,
                               MX_FRIEND,
                               MX_FRIEND,
-                              MX_FRIEND,
                               MX_FRIEND)
 #undef MX_FRIEND
 
@@ -105,7 +100,6 @@ class MX_EXPORT Fragment {
   static Fragment containing(const Designator &) noexcept;
   static std::optional<Fragment> containing(const Token &) noexcept;
   static Fragment containing(const Macro &) noexcept;
-  static std::optional<Fragment> containing(const ir::Operation &) noexcept;
   static std::optional<Fragment> containing(const VariantEntity &) noexcept;
 
   // Try to convert a variant entity into a fragment.
diff --git a/include/multiplier/Frontend/Compilation.h b/include/multiplier/Frontend/Compilation.h
index a0685a278..cdb738b7e 100644
--- a/include/multiplier/Frontend/Compilation.h
+++ b/include/multiplier/Frontend/Compilation.h
@@ -15,13 +15,6 @@
 #include "../Entity.h"
 
 namespace mx {
-namespace ir {
-class Operation;
-class SourceIRImpl;
-namespace builtin {
-class ModuleOp;
-}  // namespace builtin
-}  // namespace ir
 
 class CompilationImpl;
 class Decl;
@@ -50,8 +43,6 @@ class MX_EXPORT Compilation {
   friend class Index;
   friend class Reference;
   friend class Stmt;
-  friend class ir::SourceIRImpl;
-  friend class ir::Operation;
 
   CompilationImplPtr impl;
 
@@ -81,9 +72,6 @@ class MX_EXPORT Compilation {
   // Return the unique ID of this compilation.
   PackedCompilationId id(void) const noexcept;
 
-  // Returns source IR for the compilation.
-  std::optional<ir::builtin::ModuleOp> ir(void) const noexcept;
-
   // The fragments owned by this compilation. This will be a subset of all
   // observable fragments by this compilation, because some of them may be
   // owned by a different compilation.
diff --git a/include/multiplier/Frontend/ConditionalMacroDirective.h b/include/multiplier/Frontend/ConditionalMacroDirective.h
index d2e7cb4e9..d2fdc3e9d 100644
--- a/include/multiplier/Frontend/ConditionalMacroDirective.h
+++ b/include/multiplier/Frontend/ConditionalMacroDirective.h
@@ -17,11 +17,6 @@ class ConditionalMacroDirective;
 class File;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ConditionalMacroDirective : public MacroDirective {
  private:
diff --git a/include/multiplier/Frontend/DefineMacroDirective.h b/include/multiplier/Frontend/DefineMacroDirective.h
index db83b5109..5a5fdeea6 100644
--- a/include/multiplier/Frontend/DefineMacroDirective.h
+++ b/include/multiplier/Frontend/DefineMacroDirective.h
@@ -18,11 +18,6 @@ class File;
 class Macro;
 class MacroDirective;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT DefineMacroDirective : public MacroDirective {
  private:
diff --git a/include/multiplier/Frontend/ElseIfDefinedMacroDirective.h b/include/multiplier/Frontend/ElseIfDefinedMacroDirective.h
index a3f537bb9..824dea1c5 100644
--- a/include/multiplier/Frontend/ElseIfDefinedMacroDirective.h
+++ b/include/multiplier/Frontend/ElseIfDefinedMacroDirective.h
@@ -18,11 +18,6 @@ class ElseIfDefinedMacroDirective;
 class File;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ElseIfDefinedMacroDirective : public ConditionalMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/ElseIfMacroDirective.h b/include/multiplier/Frontend/ElseIfMacroDirective.h
index 057b29dbf..0c6ad0883 100644
--- a/include/multiplier/Frontend/ElseIfMacroDirective.h
+++ b/include/multiplier/Frontend/ElseIfMacroDirective.h
@@ -18,11 +18,6 @@ class ElseIfMacroDirective;
 class File;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ElseIfMacroDirective : public ConditionalMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/ElseIfNotDefinedMacroDirective.h b/include/multiplier/Frontend/ElseIfNotDefinedMacroDirective.h
index ea08870ec..9f9de7d57 100644
--- a/include/multiplier/Frontend/ElseIfNotDefinedMacroDirective.h
+++ b/include/multiplier/Frontend/ElseIfNotDefinedMacroDirective.h
@@ -18,11 +18,6 @@ class ElseIfNotDefinedMacroDirective;
 class File;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ElseIfNotDefinedMacroDirective : public ConditionalMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/ElseMacroDirective.h b/include/multiplier/Frontend/ElseMacroDirective.h
index 6a515cd12..4458f3b2f 100644
--- a/include/multiplier/Frontend/ElseMacroDirective.h
+++ b/include/multiplier/Frontend/ElseMacroDirective.h
@@ -18,11 +18,6 @@ class ElseMacroDirective;
 class File;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ElseMacroDirective : public ConditionalMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/EndIfMacroDirective.h b/include/multiplier/Frontend/EndIfMacroDirective.h
index c004df9f2..238976e0d 100644
--- a/include/multiplier/Frontend/EndIfMacroDirective.h
+++ b/include/multiplier/Frontend/EndIfMacroDirective.h
@@ -18,11 +18,6 @@ class EndIfMacroDirective;
 class File;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT EndIfMacroDirective : public ConditionalMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/File.h b/include/multiplier/Frontend/File.h
index 18cadd011..bec683d50 100644
--- a/include/multiplier/Frontend/File.h
+++ b/include/multiplier/Frontend/File.h
@@ -15,9 +15,6 @@
 #include "Token.h"
 
 namespace mx {
-namespace ir {
-class Operation;
-}  // namespace ir
 
 class EntityProvider;
 class FileLocationCache;
@@ -38,8 +35,7 @@ class TokenTree;
                               MX_FORWARD_DECLARE,
                               MX_FORWARD_DECLARE,
                               MX_FORWARD_DECLARE,
-                              MX_FORWARD_DECLARE,
-                              MX_IGNORE_ENTITY_CATEGORY)
+                              MX_FORWARD_DECLARE)
 #undef MX_FORWARD_DECLARE
 
 using FragmentIdList = std::vector<PackedFragmentId>;
@@ -108,7 +104,6 @@ class MX_EXPORT File {
                               MX_FRIEND,
                               MX_FRIEND,
                               MX_FRIEND,
-                              MX_FRIEND,
                               MX_FRIEND)
 #undef MX_FRIEND
 
@@ -136,8 +131,7 @@ class MX_EXPORT File {
                               MX_DECLARE_CONTAINING,
                               MX_DECLARE_CONTAINING,
                               MX_DECLARE_CONTAINING,
-                              MX_IGNORE_ENTITY_CATEGORY,
-                              MX_DECLARE_CONTAINING)
+                              MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_CONTAINING
 
   // Return the file containing a specific token.
diff --git a/include/multiplier/Frontend/IfDefinedMacroDirective.h b/include/multiplier/Frontend/IfDefinedMacroDirective.h
index 52d9510a7..739392055 100644
--- a/include/multiplier/Frontend/IfDefinedMacroDirective.h
+++ b/include/multiplier/Frontend/IfDefinedMacroDirective.h
@@ -18,11 +18,6 @@ class File;
 class IfDefinedMacroDirective;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IfDefinedMacroDirective : public ConditionalMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/IfMacroDirective.h b/include/multiplier/Frontend/IfMacroDirective.h
index 326b3f037..551e26143 100644
--- a/include/multiplier/Frontend/IfMacroDirective.h
+++ b/include/multiplier/Frontend/IfMacroDirective.h
@@ -18,11 +18,6 @@ class File;
 class IfMacroDirective;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IfMacroDirective : public ConditionalMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/IfNotDefinedMacroDirective.h b/include/multiplier/Frontend/IfNotDefinedMacroDirective.h
index 628487c3c..e1abddf62 100644
--- a/include/multiplier/Frontend/IfNotDefinedMacroDirective.h
+++ b/include/multiplier/Frontend/IfNotDefinedMacroDirective.h
@@ -18,11 +18,6 @@ class File;
 class IfNotDefinedMacroDirective;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IfNotDefinedMacroDirective : public ConditionalMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/ImportMacroDirective.h b/include/multiplier/Frontend/ImportMacroDirective.h
index 887c731e0..197e77231 100644
--- a/include/multiplier/Frontend/ImportMacroDirective.h
+++ b/include/multiplier/Frontend/ImportMacroDirective.h
@@ -18,11 +18,6 @@ class ImportMacroDirective;
 class IncludeLikeMacroDirective;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT ImportMacroDirective : public IncludeLikeMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/IncludeLikeMacroDirective.h b/include/multiplier/Frontend/IncludeLikeMacroDirective.h
index 6bbd38570..f0c77c06c 100644
--- a/include/multiplier/Frontend/IncludeLikeMacroDirective.h
+++ b/include/multiplier/Frontend/IncludeLikeMacroDirective.h
@@ -17,11 +17,6 @@ class File;
 class IncludeLikeMacroDirective;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IncludeLikeMacroDirective : public MacroDirective {
  private:
diff --git a/include/multiplier/Frontend/IncludeMacroDirective.h b/include/multiplier/Frontend/IncludeMacroDirective.h
index 75e9ee9f8..951a75a9b 100644
--- a/include/multiplier/Frontend/IncludeMacroDirective.h
+++ b/include/multiplier/Frontend/IncludeMacroDirective.h
@@ -18,11 +18,6 @@ class IncludeLikeMacroDirective;
 class IncludeMacroDirective;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IncludeMacroDirective : public IncludeLikeMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/IncludeMacrosMacroDirective.h b/include/multiplier/Frontend/IncludeMacrosMacroDirective.h
index e53342d95..495563203 100644
--- a/include/multiplier/Frontend/IncludeMacrosMacroDirective.h
+++ b/include/multiplier/Frontend/IncludeMacrosMacroDirective.h
@@ -18,11 +18,6 @@ class IncludeLikeMacroDirective;
 class IncludeMacrosMacroDirective;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IncludeMacrosMacroDirective : public IncludeLikeMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/IncludeNextMacroDirective.h b/include/multiplier/Frontend/IncludeNextMacroDirective.h
index 9ae1c674e..8e25b4487 100644
--- a/include/multiplier/Frontend/IncludeNextMacroDirective.h
+++ b/include/multiplier/Frontend/IncludeNextMacroDirective.h
@@ -18,11 +18,6 @@ class IncludeLikeMacroDirective;
 class IncludeNextMacroDirective;
 class Macro;
 class MacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT IncludeNextMacroDirective : public IncludeLikeMacroDirective {
  private:
diff --git a/include/multiplier/Frontend/Macro.h b/include/multiplier/Frontend/Macro.h
index 4f1f467ef..ecdb1e5e0 100644
--- a/include/multiplier/Frontend/Macro.h
+++ b/include/multiplier/Frontend/Macro.h
@@ -33,11 +33,6 @@ class Macro;
 class MacroImpl;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 using PreprocessedEntity = std::variant<Macro, Token, Fragment>;
 class MX_EXPORT Macro {
@@ -54,8 +49,7 @@ class MX_EXPORT Macro {
   friend class TokenContext;
   friend class Type;
   friend class MacroImpl;
-  friend class ir::Operation;
-  friend class ir::Value;
+
 
   std::shared_ptr<const MacroImpl> impl;
   static std::shared_ptr<EntityProvider> entity_provider_of(const Index &);
diff --git a/include/multiplier/Frontend/MacroArgument.h b/include/multiplier/Frontend/MacroArgument.h
index 14db44ef3..72d9bfe40 100644
--- a/include/multiplier/Frontend/MacroArgument.h
+++ b/include/multiplier/Frontend/MacroArgument.h
@@ -16,11 +16,6 @@ class Index;
 class File;
 class Macro;
 class MacroArgument;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroArgument : public Macro {
  private:
diff --git a/include/multiplier/Frontend/MacroConcatenate.h b/include/multiplier/Frontend/MacroConcatenate.h
index 160811afd..956d2fdd7 100644
--- a/include/multiplier/Frontend/MacroConcatenate.h
+++ b/include/multiplier/Frontend/MacroConcatenate.h
@@ -17,11 +17,6 @@ class File;
 class Macro;
 class MacroConcatenate;
 class MacroSubstitution;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroConcatenate : public MacroSubstitution {
  private:
diff --git a/include/multiplier/Frontend/MacroDirective.h b/include/multiplier/Frontend/MacroDirective.h
index 1189bf659..416b64dcb 100644
--- a/include/multiplier/Frontend/MacroDirective.h
+++ b/include/multiplier/Frontend/MacroDirective.h
@@ -17,11 +17,6 @@ class File;
 class Macro;
 class MacroDirective;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroDirective : public Macro {
  private:
diff --git a/include/multiplier/Frontend/MacroExpansion.h b/include/multiplier/Frontend/MacroExpansion.h
index 042d68fe3..2e99f0cfc 100644
--- a/include/multiplier/Frontend/MacroExpansion.h
+++ b/include/multiplier/Frontend/MacroExpansion.h
@@ -19,11 +19,6 @@ class Macro;
 class MacroArgument;
 class MacroExpansion;
 class MacroSubstitution;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroExpansion : public MacroSubstitution {
  private:
diff --git a/include/multiplier/Frontend/MacroParameter.h b/include/multiplier/Frontend/MacroParameter.h
index 6e5603feb..fc1947a2c 100644
--- a/include/multiplier/Frontend/MacroParameter.h
+++ b/include/multiplier/Frontend/MacroParameter.h
@@ -17,11 +17,6 @@ class File;
 class Macro;
 class MacroParameter;
 class Token;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroParameter : public Macro {
  private:
diff --git a/include/multiplier/Frontend/MacroParameterSubstitution.h b/include/multiplier/Frontend/MacroParameterSubstitution.h
index d3da16558..e9052a442 100644
--- a/include/multiplier/Frontend/MacroParameterSubstitution.h
+++ b/include/multiplier/Frontend/MacroParameterSubstitution.h
@@ -18,11 +18,6 @@ class Macro;
 class MacroParameter;
 class MacroParameterSubstitution;
 class MacroSubstitution;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroParameterSubstitution : public MacroSubstitution {
  private:
diff --git a/include/multiplier/Frontend/MacroStringify.h b/include/multiplier/Frontend/MacroStringify.h
index d5e5f618e..2f9dfcd55 100644
--- a/include/multiplier/Frontend/MacroStringify.h
+++ b/include/multiplier/Frontend/MacroStringify.h
@@ -17,11 +17,6 @@ class File;
 class Macro;
 class MacroStringify;
 class MacroSubstitution;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroStringify : public MacroSubstitution {
  private:
diff --git a/include/multiplier/Frontend/MacroSubstitution.h b/include/multiplier/Frontend/MacroSubstitution.h
index f4091c3d9..22a8c3723 100644
--- a/include/multiplier/Frontend/MacroSubstitution.h
+++ b/include/multiplier/Frontend/MacroSubstitution.h
@@ -18,11 +18,6 @@ class Macro;
 class MacroSubstitution;
 class Token;
 class TokenRange;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroSubstitution : public Macro {
  private:
diff --git a/include/multiplier/Frontend/MacroVAOpt.h b/include/multiplier/Frontend/MacroVAOpt.h
index 7bb33d9f0..d1c72b28a 100644
--- a/include/multiplier/Frontend/MacroVAOpt.h
+++ b/include/multiplier/Frontend/MacroVAOpt.h
@@ -16,11 +16,6 @@ class Index;
 class File;
 class Macro;
 class MacroVAOpt;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroVAOpt : public Macro {
  private:
diff --git a/include/multiplier/Frontend/MacroVAOptArgument.h b/include/multiplier/Frontend/MacroVAOptArgument.h
index 25745ba44..72e990f13 100644
--- a/include/multiplier/Frontend/MacroVAOptArgument.h
+++ b/include/multiplier/Frontend/MacroVAOptArgument.h
@@ -16,11 +16,6 @@ class Index;
 class File;
 class Macro;
 class MacroVAOptArgument;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT MacroVAOptArgument : public Macro {
  private:
diff --git a/include/multiplier/Frontend/OtherMacroDirective.h b/include/multiplier/Frontend/OtherMacroDirective.h
index bd426076f..56d48c39c 100644
--- a/include/multiplier/Frontend/OtherMacroDirective.h
+++ b/include/multiplier/Frontend/OtherMacroDirective.h
@@ -17,11 +17,6 @@ class File;
 class Macro;
 class MacroDirective;
 class OtherMacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT OtherMacroDirective : public MacroDirective {
  private:
diff --git a/include/multiplier/Frontend/PragmaMacroDirective.h b/include/multiplier/Frontend/PragmaMacroDirective.h
index 3026c1fc3..d9a8a79e7 100644
--- a/include/multiplier/Frontend/PragmaMacroDirective.h
+++ b/include/multiplier/Frontend/PragmaMacroDirective.h
@@ -17,11 +17,6 @@ class File;
 class Macro;
 class MacroDirective;
 class PragmaMacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT PragmaMacroDirective : public MacroDirective {
  private:
diff --git a/include/multiplier/Frontend/TokenContext.h b/include/multiplier/Frontend/TokenContext.h
index 166a7814e..66b1db28b 100644
--- a/include/multiplier/Frontend/TokenContext.h
+++ b/include/multiplier/Frontend/TokenContext.h
@@ -92,7 +92,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_FORWARD_DECLARE_GETTER,
                             MX_FORWARD_DECLARE_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_FORWARD_DECLARE_GETTER
 
diff --git a/include/multiplier/Frontend/UndefineMacroDirective.h b/include/multiplier/Frontend/UndefineMacroDirective.h
index 23adeadb5..3bcc70d5c 100644
--- a/include/multiplier/Frontend/UndefineMacroDirective.h
+++ b/include/multiplier/Frontend/UndefineMacroDirective.h
@@ -17,11 +17,6 @@ class File;
 class Macro;
 class MacroDirective;
 class UndefineMacroDirective;
-namespace ir {
-class Operation;
-class Value;
-}  // namespace ir
-
 #if !defined(MX_DISABLE_API) || defined(MX_ENABLE_API)
 class MX_EXPORT UndefineMacroDirective : public MacroDirective {
  private:
diff --git a/include/multiplier/IR.h b/include/multiplier/IR.h
deleted file mode 100644
index c9c9569ef..000000000
--- a/include/multiplier/IR.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "IR/Attribute.h"
-#include "IR/AttributeKind.h"
-#include "IR/Block.h"
-#include "IR/Operation.h"
-#include "IR/OperationKind.h"
-#include "IR/Region.h"
-#include "IR/Type.h"
-#include "IR/TypeKind.h"
-#include "IR/Value.h"
-
-#include "IR/Builtin/Dialect.h"
-#include "IR/LLVM/Dialect.h"
-#include "IR/MemRef/Dialect.h"
-#include "IR/ABI/Dialect.h"
-#include "IR/LowLevel/Dialect.h"
-#include "IR/HighLevel/Dialect.h"
-#include "IR/Core/Dialect.h"
-#include "IR/Meta/Dialect.h"
-#include "IR/Unsupported/Dialect.h"
diff --git a/include/multiplier/IR/ABI/Dialect.h b/include/multiplier/IR/ABI/Dialect.h
deleted file mode 100644
index e6d6fdd09..000000000
--- a/include/multiplier/IR/ABI/Dialect.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "Operation.h"
diff --git a/include/multiplier/IR/ABI/Operation.h b/include/multiplier/IR/ABI/Operation.h
deleted file mode 100644
index 9cacd108e..000000000
--- a/include/multiplier/IR/ABI/Operation.h
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Operation.h"
-
-namespace vast::abi {
-class CallArgsOp;
-class CallExecutionOp;
-class CallOp;
-class CallRetsOp;
-class DirectOp;
-class EpilogueOp;
-class FuncOp;
-class IndirectOp;
-class PrologueOp;
-class RetDirectOp;
-class YieldOp;
-}  // namespace vast::abi
-namespace mx::ir::abi {
-
-class MX_EXPORT Operation : public ::mx::ir::Operation {
- public:
-  static std::optional<Operation> from(const ::mx::ir::Operation &);
-};
-static_assert(sizeof(Operation) == sizeof(::mx::ir::Operation));
-
-class MX_EXPORT CallArgsOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_CALL_ARGS;
-  }
-
-  static std::optional<CallArgsOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CallArgsOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::CallArgsOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Result> results(void) const &;
-  ::mx::ir::Region body(void) const;
-};
-static_assert(sizeof(CallArgsOp) == sizeof(Operation));
-
-class MX_EXPORT CallExecutionOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_CALL_EXEC;
-  }
-
-  static std::optional<CallExecutionOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CallExecutionOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::CallExecutionOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> arguments(void) const &;
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region body(void) const;
-  //::mlir::SymbolRefAttr callee(void) const;
-  //::mlir::CallInterfaceCallable callable_for_callee(void) const;
-  gap::generator<::mx::ir::Operand> arg_operands(void) const &;
-};
-static_assert(sizeof(CallExecutionOp) == sizeof(Operation));
-
-class MX_EXPORT CallOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_CALL;
-  }
-
-  static std::optional<CallOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CallOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::CallOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> arguments(void) const &;
-  gap::generator<::mx::ir::Result> results(void) const &;
-  std::string_view callee(void) const;
-  //::mlir::CallInterfaceCallable callable_for_callee(void) const;
-  gap::generator<::mx::ir::Operand> arg_operands(void) const &;
-};
-static_assert(sizeof(CallOp) == sizeof(Operation));
-
-class MX_EXPORT CallRetsOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_CALL_RETS;
-  }
-
-  static std::optional<CallRetsOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CallRetsOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::CallRetsOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Result> results(void) const &;
-  ::mx::ir::Region body(void) const;
-};
-static_assert(sizeof(CallRetsOp) == sizeof(Operation));
-
-class MX_EXPORT DirectOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_DIRECT;
-  }
-
-  static std::optional<DirectOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DirectOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::DirectOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> value(void) const &;
-  gap::generator<::mx::ir::Result> result(void) const &;
-};
-static_assert(sizeof(DirectOp) == sizeof(Operation));
-
-class MX_EXPORT EpilogueOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_EPILOGUE;
-  }
-
-  static std::optional<EpilogueOp> from(const ::mx::ir::Operation &that);
-  static std::optional<EpilogueOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::EpilogueOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Result> results(void) const &;
-  ::mx::ir::Region body(void) const;
-};
-static_assert(sizeof(EpilogueOp) == sizeof(Operation));
-
-class MX_EXPORT FuncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_FUNC;
-  }
-
-  static std::optional<FuncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FuncOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::FuncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::optional<::mx::ir::Region> body(void) const;
-  std::string_view name(void) const;
-  ::mx::ir::Type function_type(void) const;
-  //::std::optional<GlobalLinkageKind> linkage(void) const;
-  std::optional<std::string_view> visibility(void) const;
-  //::std::optional<ArrayAttr> arg_attrs(void) const;
-  //::std::optional<ArrayAttr> res_attrs(void) const;
-  bool is_var_arg(void) const;
-  //::mlir::Region * callable_region(void) const;
-  gap::generator<::mx::ir::Type> callable_results(void) const &;
-  //::mlir::ArrayAttr callable_arg_attrs(void) const;
-  //::mlir::ArrayAttr callable_res_attrs(void) const;
-  gap::generator<::mx::ir::Type> argument_types(void) const &;
-  gap::generator<::mx::ir::Type> result_types(void) const &;
-  bool is_declaration(void) const;
-};
-static_assert(sizeof(FuncOp) == sizeof(Operation));
-
-class MX_EXPORT IndirectOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_INDIRECT;
-  }
-
-  static std::optional<IndirectOp> from(const ::mx::ir::Operation &that);
-  static std::optional<IndirectOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::IndirectOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(IndirectOp) == sizeof(Operation));
-
-class MX_EXPORT PrologueOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_PROLOGUE;
-  }
-
-  static std::optional<PrologueOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PrologueOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::PrologueOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Result> results(void) const &;
-  ::mx::ir::Region body(void) const;
-};
-static_assert(sizeof(PrologueOp) == sizeof(Operation));
-
-class MX_EXPORT RetDirectOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_RET_DIRECT;
-  }
-
-  static std::optional<RetDirectOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RetDirectOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::RetDirectOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  gap::generator<::mx::ir::Result> result(void) const &;
-};
-static_assert(sizeof(RetDirectOp) == sizeof(Operation));
-
-class MX_EXPORT YieldOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::ABI_YIELD;
-  }
-
-  static std::optional<YieldOp> from(const ::mx::ir::Operation &that);
-  static std::optional<YieldOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::abi::YieldOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> values(void) const &;
-  gap::generator<::mx::ir::Result> result(void) const &;
-};
-static_assert(sizeof(YieldOp) == sizeof(Operation));
-
-}  // namespace mx::ir::abi
diff --git a/include/multiplier/IR/Attribute.h b/include/multiplier/IR/Attribute.h
deleted file mode 100644
index 082011ec6..000000000
--- a/include/multiplier/IR/Attribute.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string_view>
-
-#include "AttributeKind.h"
-
-namespace mlir {
-class AttributeStorage;
-}  // namespace mlir
-namespace mx::ir {
-
-class Operation;
-class Block;
-class Argument;
-class SourceIRImpl;
-class Type;
-
-// The type of some operation / value.
-class MX_EXPORT Attribute {
- private:
-  friend class Operation;
-  friend class Block;
-  friend class Argument;
-  friend class Value;
-
- protected:
-
-  std::shared_ptr<const SourceIRImpl> module_;
-  mlir::AttributeStorage *attr_;
-  AttributeKind kind_;
-
-  inline Attribute(std::shared_ptr<const SourceIRImpl> module,
-                   mlir::AttributeStorage *attr)
-      : module_(std::move(module)),
-        attr_(attr),
-        kind_(classify(attr)) {}
-
- public:
-  inline Attribute(std::shared_ptr<const SourceIRImpl> module,
-                   void *attr)
-      : Attribute(std::move(module),
-                  reinterpret_cast<mlir::AttributeStorage *>(attr)) {}
-
-  static AttributeKind classify(mlir::AttributeStorage *attr);
-
-  inline AttributeKind kind(void) const noexcept {
-    return kind_;
-  }
-
-  inline mlir::AttributeStorage *underlying_attribute(void) const noexcept {
-    return attr_;
-  }
-
-  inline bool operator==(const Attribute &that) const noexcept {
-    return attr_ == that.attr_;
-  }
-
-  inline bool operator!=(const Attribute &that) const noexcept {
-    return attr_ != that.attr_;
-  }
-};
-
-}  // namespace mx::ir
diff --git a/include/multiplier/IR/AttributeKind.h b/include/multiplier/IR/AttributeKind.h
deleted file mode 100644
index 3cfafe905..000000000
--- a/include/multiplier/IR/AttributeKind.h
+++ /dev/null
@@ -1,168 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Compiler.h"
-
-namespace mx {
-namespace ir {
-enum class AttributeKind : unsigned {
-  UNKNOWN,
-  BUILTIN_TYPED,
-  BUILTIN_ELEMENTS,
-  BUILTIN_AFFINE_MAP,
-  BUILTIN_ARRAY,
-  BUILTIN_DENSE_ARRAY,
-  BUILTIN_DENSE_INT_OR_FP_ELEMENTS,
-  BUILTIN_DENSE_STRING_ELEMENTS,
-  BUILTIN_DENSE_RESOURCE_ELEMENTS,
-  BUILTIN_DICTIONARY,
-  BUILTIN_FLOAT,
-  BUILTIN_INTEGER,
-  BUILTIN_INTEGER_SET,
-  BUILTIN_OPAQUE,
-  BUILTIN_SPARSE_ELEMENTS,
-  BUILTIN_STRIDED_LAYOUT,
-  BUILTIN_STRING,
-  BUILTIN_SYMBOL_REF,
-  BUILTIN_TYPE,
-  BUILTIN_UNIT,
-  BUILTIN_BOOL,
-  BUILTIN_FLAT_SYMBOL_REF,
-  BUILTIN_DENSE_INT_ELEMENTS,
-  BUILTIN_DATA_LAYOUT_SPEC,
-  LLVM_C_CONV,
-  LLVM_COMDAT,
-  LLVM_LINKAGE,
-  LLVM_FRAME_POINTER_KIND,
-  LLVM_LOOP_VECTORIZE,
-  LLVM_LOOP_INTERLEAVE,
-  LLVM_LOOP_UNROLL,
-  LLVM_LOOP_UNROLL_AND_JAM,
-  LLVM_LOOP_LICM,
-  LLVM_LOOP_DISTRIBUTE,
-  LLVM_LOOP_PIPELINE,
-  LLVM_LOOP_PEELED,
-  LLVM_LOOP_UNSWITCH,
-  LLVM_LOOP_ANNOTATION,
-  LLVM_DI_EXPRESSION_ELEM,
-  LLVM_DI_EXPRESSION,
-  LLVM_DI_NULL_TYPE,
-  LLVM_DI_BASIC_TYPE,
-  LLVM_DI_COMPILE_UNIT,
-  LLVM_DI_COMPOSITE_TYPE,
-  LLVM_DI_DERIVED_TYPE,
-  LLVM_DI_FILE,
-  LLVM_DI_GLOBAL_VARIABLE_EXPRESSION,
-  LLVM_DI_GLOBAL_VARIABLE,
-  LLVM_DI_LEXICAL_BLOCK,
-  LLVM_DI_LEXICAL_BLOCK_FILE,
-  LLVM_DI_LOCAL_VARIABLE,
-  LLVM_DI_SUBPROGRAM,
-  LLVM_DI_MODULE,
-  LLVM_DI_NAMESPACE,
-  LLVM_DI_SUBRANGE,
-  LLVM_DI_SUBROUTINE_TYPE,
-  LLVM_DI_LABEL,
-  LLVM_MEMORY_EFFECTS,
-  LLVM_ALIAS_SCOPE_DOMAIN,
-  LLVM_ALIAS_SCOPE,
-  LLVM_ACCESS_GROUP,
-  LLVM_TBAA_ROOT,
-  LLVM_TBAA_MEMBER,
-  LLVM_TBAA_TYPE_DESCRIPTOR,
-  LLVM_TBAA_TAG,
-  LLVM_V_SCALE_RANGE,
-  LLVM_TARGET_FEATURES,
-  LLVM_INTEGER_OVERFLOW_FLAGS,
-  LLVM_FASTMATH_FLAGS,
-  HL_ANNOTATION,
-  HL_FORMAT,
-  HL_SECTION,
-  HL_ALIAS,
-  HL_ERROR,
-  HL_COUNTED_BY,
-  HL_CLEANUP,
-  HL_ALIGNED,
-  HL_ALWAYS_INLINE,
-  HL_NO_INLINE,
-  HL_CONST,
-  HL_LOADER_UNINITIALIZED,
-  HL_NO_INSTRUMENT_FUNCTION,
-  HL_PACKED,
-  HL_PURE,
-  HL_WARN_UNUSED_RESULT,
-  HL_RESTRICT,
-  HL_NO_THROW,
-  HL_NON_NULL,
-  HL_LEAF,
-  HL_COLD,
-  HL_TRANSPARENT_UNION,
-  HL_RETURNS_TWICE,
-  HL_MAY_ALIAS,
-  HL_UNUSED,
-  HL_USED,
-  HL_GNU_INLINE,
-  HL_NO_CF_CHECK,
-  HL_AVAILABLE_ONLY_IN_DEFAULT_EVAL_METHOD,
-  HL_AVAILABILITY_ATTR,
-  HL_FALLTHROUGH,
-  HL_NO_PROFILE_INSTRUMENT_FUNCTION,
-  HL_ASM_LABEL,
-  HL_MODE,
-  HL_BUILTIN,
-  HL_ALLOC_ALIGN,
-  HL_ALLOC_SIZE,
-  HL_DEPRECATED,
-  HL_MAX_FIELD_ALIGNMENT,
-  HL_VISIBILITY,
-  HL_ASSUME_ALIGNED,
-  HL_CV_QUALIFIERS,
-  HL_UCV_QUALIFIERS,
-  HL_CVR_QUALIFIERS,
-  HL_OFFSET_OF_NODE,
-  CORE_BOOLEAN,
-  CORE_INTEGER,
-  CORE_FLOAT,
-  CORE_VOID,
-  CORE_SOURCE_LANGUAGE,
-  CORE_GLOBAL_LINKAGE_KIND,
-  META_IDENTIFIER,
-};
-
-}  // namespace ir
-
-inline static const char *EnumerationName(ir::AttributeKind) {
-  return "AttributeKind";
-}
-
-inline static constexpr unsigned NumEnumerators(ir::AttributeKind) {
-  return 120;
-}
-
-MX_EXPORT const char *EnumeratorName(ir::AttributeKind);
-
-MX_EXPORT bool IsBuiltinAttributeKind(ir::AttributeKind);
-
-MX_EXPORT bool IsLLVMIRAttributeKind(ir::AttributeKind);
-
-MX_EXPORT bool IsMemRefAttributeKind(ir::AttributeKind);
-
-MX_EXPORT bool IsABIAttributeKind(ir::AttributeKind);
-
-MX_EXPORT bool IsLowLevelAttributeKind(ir::AttributeKind);
-
-MX_EXPORT bool IsHighLevelAttributeKind(ir::AttributeKind);
-
-MX_EXPORT bool IsCoreAttributeKind(ir::AttributeKind);
-
-MX_EXPORT bool IsMetaAttributeKind(ir::AttributeKind);
-
-MX_EXPORT bool IsUnsupportedAttributeKind(ir::AttributeKind);
-
-}  // namespace mx
diff --git a/include/multiplier/IR/Block.h b/include/multiplier/IR/Block.h
deleted file mode 100644
index 0b35c7967..000000000
--- a/include/multiplier/IR/Block.h
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#pragma once
-
-#include <gap/coro/generator.hpp>
-#include <memory>
-
-#include "Value.h"
-
-namespace mlir {
-class Block;
-class BlockArgument;
-class BlockOperand;
-}  // namespace mlir
-namespace mx::ir {
-
-class Argument;
-class Label;
-class Operation;
-class Region;
-class SourceIRImpl;
-
-// A region is owned by an operation (not all operations own regions)
-// and contain one or more blocks.
-class MX_EXPORT Block final {
- private:
-  friend class Operation;
-  friend class Region;
-  friend class Argument;
-  friend class Label;
-
-  std::shared_ptr<const SourceIRImpl> module_;
-  mlir::Block *block_;
-
- public:
-  Block(std::shared_ptr<const SourceIRImpl> module,
-        mlir::Block *block);
-
-  inline Block(std::shared_ptr<const SourceIRImpl> module,
-               mlir::Block &block)
-      : Block(std::move(module), &block) {}
-
-  // Return the block containing a given argument.
-  static Block containing(const Argument &);
-
-  // We almost always have an owning block for an operation. The exception is
-  // the `mx::ir::builtin::ModuleOp` case.
-  static std::optional<Block> containing(const Operation &);
-
-  unsigned num_arguments(void) const noexcept;
-
-  std::optional<Argument> nth_argument(unsigned) const noexcept;
-
-  // Arguments to the block. Block arguments are like PHI nodes.
-  gap::generator<Argument> arguments(void) const & noexcept;
-
-  // Operations within a block. Every block has at least one operation, its
-  // terminator.
-  gap::generator<Operation> operations(void) const & noexcept;
-
-  // Operations within a block in reverse order.
-  gap::generator<Operation> reverse_operations(void) const & noexcept;
-
-  // Set of operands that use this block. For example, a block can be an
-  // operand to a terminator operation.
-  gap::generator<Label> uses(void) const & noexcept;
-
-  // Return the terminating operation of a block.
-  Operation terminator(void) const noexcept;
-
-  inline mlir::Block *underlying_block(void) const noexcept {
-    return block_;
-  }
-
-  bool operator==(const Block &that) const noexcept;
-  bool operator!=(const Block &that) const noexcept = default;
-};
-
-// An parameter to a block is like a PHI node in an SSA IR. It provides a merge
-// point for values used by this block (or made available to successors) that
-// that come from predecessors.
-class MX_EXPORT Argument final : public Value {
- private:
-  friend class Block;
-  friend class Region;
-  friend class Value;
-
-  inline Argument(std::shared_ptr<const SourceIRImpl> module,
-                  mlir::detail::BlockArgumentImpl *arg)
-      : Value(std::move(module), arg) {}
-
- public:
-
-  inline static constexpr ValueKind static_kind(void) noexcept {
-    return ValueKind::BLOCK_ARGUMENT;
-  }
-
-  static std::optional<Argument> from(const Value &val);
-
-  // Index of this block argument.
-  unsigned index(void) const noexcept;
-
-  bool operator==(const Argument &that) const noexcept;
-  bool operator!=(const Argument &that) const noexcept = default;
-};
-
-static_assert(sizeof(Argument) == sizeof(Value));
-
-// A use of a block, e.g. in a terminator operation.
-class MX_EXPORT Label final {
- private:
-  friend class Block;
-  friend class Label;
-  friend class Operation;
-  friend class Value;
-
-  std::shared_ptr<const SourceIRImpl> module_;
-  mlir::BlockOperand *op_;
-
-  inline Label(std::shared_ptr<const SourceIRImpl> module,
-               mlir::BlockOperand *op)
-      : module_(std::move(module)),
-        op_(op) {}
-
- public:
-  // The operation containing this operand.
-  Operation operation(void) const noexcept;
-
-  // The block referenced by this label.
-  Block block(void) const noexcept;
-
-  // The index of this operand within its owner operation's block operand list.
-  unsigned index(void) const noexcept;
-
-  bool operator==(const Label &that) const noexcept;
-  bool operator!=(const Label &that) const noexcept = default;
-};
-
-}  // namespace mx::ir
diff --git a/include/multiplier/IR/Builtin/Attribute.h b/include/multiplier/IR/Builtin/Attribute.h
deleted file mode 100644
index 61c3606ff..000000000
--- a/include/multiplier/IR/Builtin/Attribute.h
+++ /dev/null
@@ -1,436 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Attribute.h"
-
-namespace mlir {
-class TypedAttr;
-class ElementsAttr;
-class AffineMapAttr;
-class ArrayAttr;
-class DenseArrayAttr;
-class DenseIntOrFPElementsAttr;
-class DenseStringElementsAttr;
-class DenseResourceElementsAttr;
-class DictionaryAttr;
-class FloatAttr;
-class IntegerAttr;
-class IntegerSetAttr;
-class OpaqueAttr;
-class SparseElementsAttr;
-class StridedLayoutAttr;
-class StringAttr;
-class SymbolRefAttr;
-class TypeAttr;
-class UnitAttr;
-class BoolAttr;
-class FlatSymbolRefAttr;
-class DenseIntElementsAttr;
-class DataLayoutSpecAttr;
-}  // namespace mlir
-namespace mx::ir::builtin {
-
-class MX_EXPORT Attribute : public ::mx::ir::Attribute {
- public:
-  static std::optional<Attribute> from(const ::mx::ir::Attribute &);
-};
-static_assert(sizeof(Attribute) == sizeof(::mx::ir::Attribute));
-
-class MX_EXPORT TypedAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_TYPED;
-  }
-
-  static std::optional<TypedAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::TypedAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Type type(void) const;
-};
-static_assert(sizeof(TypedAttr) == sizeof(Attribute));
-
-class MX_EXPORT ElementsAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_ELEMENTS;
-  }
-
-  static std::optional<ElementsAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::ElementsAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool is_splat(void) const;
-  //::mlir::ShapedType shaped_type(void) const;
-  //Type element_type(void) const;
-  int64_t num_elements(void) const;
-  int64_t size(void) const;
-  bool empty(void) const;
-  ::mx::ir::Type type(void) const;
-};
-static_assert(sizeof(ElementsAttr) == sizeof(Attribute));
-
-class MX_EXPORT AffineMapAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_AFFINE_MAP;
-  }
-
-  static std::optional<AffineMapAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::AffineMapAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //AffineMap affine_map(void) const;
-  //AffineMap value(void) const;
-};
-static_assert(sizeof(AffineMapAttr) == sizeof(Attribute));
-
-class MX_EXPORT ArrayAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_ARRAY;
-  }
-
-  static std::optional<ArrayAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::ArrayAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //iterator begin(void) const;
-  //iterator end(void) const;
-  size_t size(void) const;
-  bool empty(void) const;
-  //::llvm::ArrayRef<Attribute> value(void) const;
-};
-static_assert(sizeof(ArrayAttr) == sizeof(Attribute));
-
-class MX_EXPORT DenseArrayAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_DENSE_ARRAY;
-  }
-
-  static std::optional<DenseArrayAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::DenseArrayAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  int64_t size(void) const;
-  bool empty(void) const;
-  //Type element_type(void) const;
-  //::llvm::ArrayRef<char> raw_data(void) const;
-};
-static_assert(sizeof(DenseArrayAttr) == sizeof(Attribute));
-
-class MX_EXPORT DenseIntOrFPElementsAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_DENSE_INT_OR_FP_ELEMENTS;
-  }
-
-  static std::optional<DenseIntOrFPElementsAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::DenseIntOrFPElementsAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(DenseIntOrFPElementsAttr) == sizeof(Attribute));
-
-class MX_EXPORT DenseStringElementsAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_DENSE_STRING_ELEMENTS;
-  }
-
-  static std::optional<DenseStringElementsAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::DenseStringElementsAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(DenseStringElementsAttr) == sizeof(Attribute));
-
-class MX_EXPORT DenseResourceElementsAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_DENSE_RESOURCE_ELEMENTS;
-  }
-
-  static std::optional<DenseResourceElementsAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::DenseResourceElementsAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //ShapedType type(void) const;
-  //DenseResourceElementsHandle raw_handle(void) const;
-};
-static_assert(sizeof(DenseResourceElementsAttr) == sizeof(Attribute));
-
-class MX_EXPORT DictionaryAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_DICTIONARY;
-  }
-
-  static std::optional<DictionaryAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::DictionaryAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //iterator begin(void) const;
-  //iterator end(void) const;
-  bool empty(void) const;
-  size_t size(void) const;
-  //::llvm::ArrayRef<NamedAttribute> value(void) const;
-};
-static_assert(sizeof(DictionaryAttr) == sizeof(Attribute));
-
-class MX_EXPORT FloatAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_FLOAT;
-  }
-
-  static std::optional<FloatAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::FloatAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  double value_as_double(void) const;
-  ::mx::ir::Type type(void) const;
-  //::llvm::APFloat value(void) const;
-};
-static_assert(sizeof(FloatAttr) == sizeof(Attribute));
-
-class MX_EXPORT IntegerAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_INTEGER;
-  }
-
-  static std::optional<IntegerAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::IntegerAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  int64_t integer_value(void) const;
-  int64_t signed_integer_value(void) const;
-  uint64_t unsigned_integer_value(void) const;
-  //APSInt aps_int(void) const;
-  ::mx::ir::Type type(void) const;
-  //APInt value(void) const;
-};
-static_assert(sizeof(IntegerAttr) == sizeof(Attribute));
-
-class MX_EXPORT IntegerSetAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_INTEGER_SET;
-  }
-
-  static std::optional<IntegerSetAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::IntegerSetAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //IntegerSet value(void) const;
-};
-static_assert(sizeof(IntegerSetAttr) == sizeof(Attribute));
-
-class MX_EXPORT OpaqueAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_OPAQUE;
-  }
-
-  static std::optional<OpaqueAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::OpaqueAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //StringAttr dialect_namespace(void) const;
-  std::string_view attr_data(void) const;
-  ::mx::ir::Type type(void) const;
-};
-static_assert(sizeof(OpaqueAttr) == sizeof(Attribute));
-
-class MX_EXPORT SparseElementsAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_SPARSE_ELEMENTS;
-  }
-
-  static std::optional<SparseElementsAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::SparseElementsAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //APFloat zero_ap_float(void) const;
-  //APInt zero_ap_int(void) const;
-  //Attribute zero_attr(void) const;
-  //std::vector<long, allocator<long>> flattened_sparse_indices(void) const;
-  //ShapedType type(void) const;
-  //DenseIntElementsAttr indices(void) const;
-  //DenseElementsAttr values(void) const;
-};
-static_assert(sizeof(SparseElementsAttr) == sizeof(Attribute));
-
-class MX_EXPORT StridedLayoutAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_STRIDED_LAYOUT;
-  }
-
-  static std::optional<StridedLayoutAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::StridedLayoutAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  int64_t offset(void) const;
-  //::llvm::ArrayRef<long long> strides(void) const;
-  //::mlir::AffineMap affine_map(void) const;
-};
-static_assert(sizeof(StridedLayoutAttr) == sizeof(Attribute));
-
-class MX_EXPORT StringAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_STRING;
-  }
-
-  static std::optional<StringAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::StringAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Dialect * referenced_dialect(void) const;
-  //StringRef strref(void) const;
-  std::string str(void) const;
-  //const char * data(void) const;
-  size_t size(void) const;
-  bool empty(void) const;
-  //StringRef::iterator begin(void) const;
-  //StringRef::iterator end(void) const;
-  std::string_view value(void) const;
-  ::mx::ir::Type type(void) const;
-};
-static_assert(sizeof(StringAttr) == sizeof(Attribute));
-
-class MX_EXPORT SymbolRefAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_SYMBOL_REF;
-  }
-
-  static std::optional<SymbolRefAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::SymbolRefAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //StringAttr leaf_reference(void) const;
-  //StringAttr root_reference(void) const;
-  //::llvm::ArrayRef<FlatSymbolRefAttr> nested_references(void) const;
-};
-static_assert(sizeof(SymbolRefAttr) == sizeof(Attribute));
-
-class MX_EXPORT TypeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_TYPE;
-  }
-
-  static std::optional<TypeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::TypeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type value(void) const;
-};
-static_assert(sizeof(TypeAttr) == sizeof(Attribute));
-
-class MX_EXPORT UnitAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_UNIT;
-  }
-
-  static std::optional<UnitAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::UnitAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(UnitAttr) == sizeof(Attribute));
-
-class MX_EXPORT BoolAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_BOOL;
-  }
-
-  static std::optional<BoolAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::BoolAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool value(void) const;
-};
-static_assert(sizeof(BoolAttr) == sizeof(Attribute));
-
-class MX_EXPORT FlatSymbolRefAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_FLAT_SYMBOL_REF;
-  }
-
-  static std::optional<FlatSymbolRefAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::FlatSymbolRefAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //StringAttr attr(void) const;
-  //StringRef value(void) const;
-};
-static_assert(sizeof(FlatSymbolRefAttr) == sizeof(Attribute));
-
-class MX_EXPORT DenseIntElementsAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_DENSE_INT_ELEMENTS;
-  }
-
-  static std::optional<DenseIntElementsAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::DenseIntElementsAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //iterator begin(void) const;
-  //iterator end(void) const;
-};
-static_assert(sizeof(DenseIntElementsAttr) == sizeof(Attribute));
-
-class MX_EXPORT DataLayoutSpecAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::BUILTIN_DATA_LAYOUT_SPEC;
-  }
-
-  static std::optional<DataLayoutSpecAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::DataLayoutSpecAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DataLayoutEntryListRef entries(void) const;
-};
-static_assert(sizeof(DataLayoutSpecAttr) == sizeof(Attribute));
-
-}  // namespace mx::ir::builtin
diff --git a/include/multiplier/IR/Builtin/Dialect.h b/include/multiplier/IR/Builtin/Dialect.h
deleted file mode 100644
index cdb370293..000000000
--- a/include/multiplier/IR/Builtin/Dialect.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "Attribute.h"
-#include "Type.h"
-#include "Operation.h"
diff --git a/include/multiplier/IR/Builtin/Operation.h b/include/multiplier/IR/Builtin/Operation.h
deleted file mode 100644
index 19c18d9ee..000000000
--- a/include/multiplier/IR/Builtin/Operation.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Operation.h"
-
-namespace mlir {
-class ModuleOp;
-class UnrealizedConversionCastOp;
-}  // namespace mlir
-namespace mx::ir::builtin {
-
-class MX_EXPORT Operation : public ::mx::ir::Operation {
- public:
-  static std::optional<Operation> from(const ::mx::ir::Operation &);
-};
-static_assert(sizeof(Operation) == sizeof(::mx::ir::Operation));
-
-class MX_EXPORT ModuleOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::BUILTIN_MODULE;
-  }
-
-  static std::optional<ModuleOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ModuleOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::ModuleOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body_region(void) const;
-  std::optional<std::string_view> name(void) const;
-  std::optional<std::string_view> visibility(void) const;
-  bool is_optional_symbol(void) const;
-  //DataLayoutSpecInterface data_layout_spec(void) const;
-  std::string_view default_dialect(void) const;
-};
-static_assert(sizeof(ModuleOp) == sizeof(Operation));
-
-class MX_EXPORT UnrealizedConversionCastOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::BUILTIN_UNREALIZED_CONVERSION_CAST;
-  }
-
-  static std::optional<UnrealizedConversionCastOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UnrealizedConversionCastOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::UnrealizedConversionCastOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> inputs(void) const &;
-  gap::generator<::mx::ir::Result> outputs(void) const &;
-};
-static_assert(sizeof(UnrealizedConversionCastOp) == sizeof(Operation));
-
-}  // namespace mx::ir::builtin
diff --git a/include/multiplier/IR/Builtin/Type.h b/include/multiplier/IR/Builtin/Type.h
deleted file mode 100644
index 71a5718a9..000000000
--- a/include/multiplier/IR/Builtin/Type.h
+++ /dev/null
@@ -1,433 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Type.h"
-
-namespace mlir {
-class ShapedType;
-class FloatType;
-class ComplexType;
-class Float8E5M2Type;
-class Float8E4M3FNType;
-class Float8E5M2FNUZType;
-class Float8E4M3FNUZType;
-class Float8E4M3B11FNUZType;
-class BFloat16Type;
-class Float16Type;
-class FloatTF32Type;
-class Float32Type;
-class Float64Type;
-class Float80Type;
-class Float128Type;
-class FunctionType;
-class IndexType;
-class IntegerType;
-class MemRefType;
-class NoneType;
-class OpaqueType;
-class RankedTensorType;
-class TupleType;
-class UnrankedMemRefType;
-class UnrankedTensorType;
-class VectorType;
-}  // namespace mlir
-namespace mx::ir::builtin {
-
-class MX_EXPORT Type : public ::mx::ir::Type {
- public:
-  static std::optional<Type> from(const ::mx::ir::Type &);
-};
-static_assert(sizeof(Type) == sizeof(::mx::ir::Type));
-
-class MX_EXPORT ShapedType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_SHAPED;
-  }
-
-  static std::optional<ShapedType> from(const ::mx::ir::Type &that);
-  ::mlir::ShapedType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Type element_type(void) const;
-  bool has_rank(void) const;
-  //::llvm::ArrayRef<long long> shape(void) const;
-  unsigned int element_type_bit_width(void) const;
-  int64_t rank(void) const;
-  int64_t num_elements(void) const;
-  bool has_static_shape(void) const;
-  int64_t num_dynamic_dims(void) const;
-};
-static_assert(sizeof(ShapedType) == sizeof(Type));
-
-class MX_EXPORT FloatType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT;
-  }
-
-  static std::optional<FloatType> from(const ::mx::ir::Type &that);
-  ::mlir::FloatType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int width(void) const;
-  unsigned int fp_mantissa_width(void) const;
-  //const llvm::fltSemantics & float_semantics(void) const;
-};
-static_assert(sizeof(FloatType) == sizeof(Type));
-
-class MX_EXPORT ComplexType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_COMPLEX;
-  }
-
-  static std::optional<ComplexType> from(const ::mx::ir::Type &that);
-  ::mlir::ComplexType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-};
-static_assert(sizeof(ComplexType) == sizeof(Type));
-
-class MX_EXPORT Float8E5M2Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT8_E5_M2;
-  }
-
-  static std::optional<Float8E5M2Type> from(const ::mx::ir::Type &that);
-  ::mlir::Float8E5M2Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float8E5M2Type) == sizeof(Type));
-
-class MX_EXPORT Float8E4M3FNType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT8_E4_M3_FN;
-  }
-
-  static std::optional<Float8E4M3FNType> from(const ::mx::ir::Type &that);
-  ::mlir::Float8E4M3FNType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float8E4M3FNType) == sizeof(Type));
-
-class MX_EXPORT Float8E5M2FNUZType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT8_E5_M2_FNUZ;
-  }
-
-  static std::optional<Float8E5M2FNUZType> from(const ::mx::ir::Type &that);
-  ::mlir::Float8E5M2FNUZType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float8E5M2FNUZType) == sizeof(Type));
-
-class MX_EXPORT Float8E4M3FNUZType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT8_E4_M3_FNUZ;
-  }
-
-  static std::optional<Float8E4M3FNUZType> from(const ::mx::ir::Type &that);
-  ::mlir::Float8E4M3FNUZType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float8E4M3FNUZType) == sizeof(Type));
-
-class MX_EXPORT Float8E4M3B11FNUZType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT8_E4_M3_B11_FNUZ;
-  }
-
-  static std::optional<Float8E4M3B11FNUZType> from(const ::mx::ir::Type &that);
-  ::mlir::Float8E4M3B11FNUZType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float8E4M3B11FNUZType) == sizeof(Type));
-
-class MX_EXPORT BFloat16Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_B_FLOAT16;
-  }
-
-  static std::optional<BFloat16Type> from(const ::mx::ir::Type &that);
-  ::mlir::BFloat16Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(BFloat16Type) == sizeof(Type));
-
-class MX_EXPORT Float16Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT16;
-  }
-
-  static std::optional<Float16Type> from(const ::mx::ir::Type &that);
-  ::mlir::Float16Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float16Type) == sizeof(Type));
-
-class MX_EXPORT FloatTF32Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT_TF32;
-  }
-
-  static std::optional<FloatTF32Type> from(const ::mx::ir::Type &that);
-  ::mlir::FloatTF32Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(FloatTF32Type) == sizeof(Type));
-
-class MX_EXPORT Float32Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT32;
-  }
-
-  static std::optional<Float32Type> from(const ::mx::ir::Type &that);
-  ::mlir::Float32Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float32Type) == sizeof(Type));
-
-class MX_EXPORT Float64Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT64;
-  }
-
-  static std::optional<Float64Type> from(const ::mx::ir::Type &that);
-  ::mlir::Float64Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float64Type) == sizeof(Type));
-
-class MX_EXPORT Float80Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT80;
-  }
-
-  static std::optional<Float80Type> from(const ::mx::ir::Type &that);
-  ::mlir::Float80Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float80Type) == sizeof(Type));
-
-class MX_EXPORT Float128Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FLOAT128;
-  }
-
-  static std::optional<Float128Type> from(const ::mx::ir::Type &that);
-  ::mlir::Float128Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(Float128Type) == sizeof(Type));
-
-class MX_EXPORT FunctionType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_FUNCTION;
-  }
-
-  static std::optional<FunctionType> from(const ::mx::ir::Type &that);
-  ::mlir::FunctionType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int num_inputs(void) const;
-  unsigned int num_results(void) const;
-  //ArrayRef<Type> inputs(void) const;
-  //ArrayRef<Type> results(void) const;
-};
-static_assert(sizeof(FunctionType) == sizeof(Type));
-
-class MX_EXPORT IndexType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_INDEX;
-  }
-
-  static std::optional<IndexType> from(const ::mx::ir::Type &that);
-  ::mlir::IndexType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(IndexType) == sizeof(Type));
-
-class MX_EXPORT IntegerType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_INTEGER;
-  }
-
-  static std::optional<IntegerType> from(const ::mx::ir::Type &that);
-  ::mlir::IntegerType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool is_signless(void) const;
-  bool is_signed(void) const;
-  bool is_unsigned(void) const;
-  unsigned int width(void) const;
-  //SignednessSemantics signedness(void) const;
-};
-static_assert(sizeof(IntegerType) == sizeof(Type));
-
-class MX_EXPORT MemRefType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_MEM_REF;
-  }
-
-  static std::optional<MemRefType> from(const ::mx::ir::Type &that);
-  ::mlir::MemRefType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int memory_space_as_int(void) const;
-  //::llvm::ArrayRef<long long> shape(void) const;
-  //Type element_type(void) const;
-  //MemRefLayoutAttrInterface layout(void) const;
-  //Attribute memory_space(void) const;
-};
-static_assert(sizeof(MemRefType) == sizeof(Type));
-
-class MX_EXPORT NoneType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_NONE;
-  }
-
-  static std::optional<NoneType> from(const ::mx::ir::Type &that);
-  ::mlir::NoneType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(NoneType) == sizeof(Type));
-
-class MX_EXPORT OpaqueType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_OPAQUE;
-  }
-
-  static std::optional<OpaqueType> from(const ::mx::ir::Type &that);
-  ::mlir::OpaqueType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //StringAttr dialect_namespace(void) const;
-  std::string_view type_data(void) const;
-};
-static_assert(sizeof(OpaqueType) == sizeof(Type));
-
-class MX_EXPORT RankedTensorType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_RANKED_TENSOR;
-  }
-
-  static std::optional<RankedTensorType> from(const ::mx::ir::Type &that);
-  ::mlir::RankedTensorType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::llvm::ArrayRef<long long> shape(void) const;
-  //Type element_type(void) const;
-  //Attribute encoding(void) const;
-};
-static_assert(sizeof(RankedTensorType) == sizeof(Type));
-
-class MX_EXPORT TupleType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_TUPLE;
-  }
-
-  static std::optional<TupleType> from(const ::mx::ir::Type &that);
-  ::mlir::TupleType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  size_t size(void) const;
-  //iterator begin(void) const;
-  //iterator end(void) const;
-  //ArrayRef<Type> types(void) const;
-};
-static_assert(sizeof(TupleType) == sizeof(Type));
-
-class MX_EXPORT UnrankedMemRefType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_UNRANKED_MEM_REF;
-  }
-
-  static std::optional<UnrankedMemRefType> from(const ::mx::ir::Type &that);
-  ::mlir::UnrankedMemRefType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //ArrayRef<long long> shape(void) const;
-  unsigned int memory_space_as_int(void) const;
-  //Type element_type(void) const;
-  //Attribute memory_space(void) const;
-};
-static_assert(sizeof(UnrankedMemRefType) == sizeof(Type));
-
-class MX_EXPORT UnrankedTensorType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_UNRANKED_TENSOR;
-  }
-
-  static std::optional<UnrankedTensorType> from(const ::mx::ir::Type &that);
-  ::mlir::UnrankedTensorType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //ArrayRef<long long> shape(void) const;
-  //Type element_type(void) const;
-};
-static_assert(sizeof(UnrankedTensorType) == sizeof(Type));
-
-class MX_EXPORT VectorType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::BUILTIN_VECTOR;
-  }
-
-  static std::optional<VectorType> from(const ::mx::ir::Type &that);
-  ::mlir::VectorType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool is_scalable(void) const;
-  bool all_dims_scalable(void) const;
-  bool has_rank(void) const;
-  //::llvm::ArrayRef<long long> shape(void) const;
-  //Type element_type(void) const;
-  //::llvm::ArrayRef<bool> scalable_dims(void) const;
-};
-static_assert(sizeof(VectorType) == sizeof(Type));
-
-}  // namespace mx::ir::builtin
diff --git a/include/multiplier/IR/Core/Attribute.h b/include/multiplier/IR/Core/Attribute.h
deleted file mode 100644
index 8e847e65a..000000000
--- a/include/multiplier/IR/Core/Attribute.h
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Attribute.h"
-
-namespace vast::core {
-class BooleanAttr;
-class IntegerAttr;
-class FloatAttr;
-class VoidAttr;
-class SourceLanguageAttr;
-class GlobalLinkageKindAttr;
-}  // namespace vast::core
-namespace mx::ir::core {
-
-class MX_EXPORT Attribute : public ::mx::ir::Attribute {
- public:
-  static std::optional<Attribute> from(const ::mx::ir::Attribute &);
-};
-static_assert(sizeof(Attribute) == sizeof(::mx::ir::Attribute));
-
-class MX_EXPORT BooleanAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::CORE_BOOLEAN;
-  }
-
-  static std::optional<BooleanAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::core::BooleanAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Type type(void) const;
-  bool value(void) const;
-};
-static_assert(sizeof(BooleanAttr) == sizeof(Attribute));
-
-class MX_EXPORT IntegerAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::CORE_INTEGER;
-  }
-
-  static std::optional<IntegerAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::core::IntegerAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Type type(void) const;
-  //::llvm::APSInt value(void) const;
-};
-static_assert(sizeof(IntegerAttr) == sizeof(Attribute));
-
-class MX_EXPORT FloatAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::CORE_FLOAT;
-  }
-
-  static std::optional<FloatAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::core::FloatAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Type type(void) const;
-  //::llvm::APFloat value(void) const;
-};
-static_assert(sizeof(FloatAttr) == sizeof(Attribute));
-
-class MX_EXPORT VoidAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::CORE_VOID;
-  }
-
-  static std::optional<VoidAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::core::VoidAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Type type(void) const;
-};
-static_assert(sizeof(VoidAttr) == sizeof(Attribute));
-
-class MX_EXPORT SourceLanguageAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::CORE_SOURCE_LANGUAGE;
-  }
-
-  static std::optional<SourceLanguageAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::core::SourceLanguageAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::vast::core::SourceLanguage value(void) const;
-};
-static_assert(sizeof(SourceLanguageAttr) == sizeof(Attribute));
-
-class MX_EXPORT GlobalLinkageKindAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::CORE_GLOBAL_LINKAGE_KIND;
-  }
-
-  static std::optional<GlobalLinkageKindAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::core::GlobalLinkageKindAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::vast::core::GlobalLinkageKind value(void) const;
-};
-static_assert(sizeof(GlobalLinkageKindAttr) == sizeof(Attribute));
-
-}  // namespace mx::ir::core
diff --git a/include/multiplier/IR/Core/Dialect.h b/include/multiplier/IR/Core/Dialect.h
deleted file mode 100644
index cdb370293..000000000
--- a/include/multiplier/IR/Core/Dialect.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "Attribute.h"
-#include "Type.h"
-#include "Operation.h"
diff --git a/include/multiplier/IR/Core/Operation.h b/include/multiplier/IR/Core/Operation.h
deleted file mode 100644
index 4976d3761..000000000
--- a/include/multiplier/IR/Core/Operation.h
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Operation.h"
-
-namespace vast::core {
-class BinLAndOp;
-class BinLOrOp;
-class ImplicitReturnOp;
-class LazyOp;
-class ModuleOp;
-class ScopeOp;
-class SelectOp;
-}  // namespace vast::core
-namespace mx::ir::core {
-
-class MX_EXPORT Operation : public ::mx::ir::Operation {
- public:
-  static std::optional<Operation> from(const ::mx::ir::Operation &);
-};
-static_assert(sizeof(Operation) == sizeof(::mx::ir::Operation));
-
-class MX_EXPORT BinLAndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::CORE_BIN_LAND;
-  }
-
-  static std::optional<BinLAndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinLAndOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::core::BinLAndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinLAndOp) == sizeof(Operation));
-
-class MX_EXPORT BinLOrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::CORE_BIN_LOR;
-  }
-
-  static std::optional<BinLOrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinLOrOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::core::BinLOrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinLOrOp) == sizeof(Operation));
-
-class MX_EXPORT ImplicitReturnOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::CORE_IMPLICIT_RETURN;
-  }
-
-  static std::optional<ImplicitReturnOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ImplicitReturnOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::core::ImplicitReturnOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> result(void) const &;
-};
-static_assert(sizeof(ImplicitReturnOp) == sizeof(Operation));
-
-class MX_EXPORT LazyOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::CORE_LAZY_OP;
-  }
-
-  static std::optional<LazyOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LazyOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::core::LazyOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region lazy(void) const;
-};
-static_assert(sizeof(LazyOp) == sizeof(Operation));
-
-class MX_EXPORT ModuleOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::CORE_MODULE;
-  }
-
-  static std::optional<ModuleOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ModuleOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::core::ModuleOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body(void) const;
-  std::optional<std::string_view> name(void) const;
-  bool is_optional_symbol(void) const;
-  //mlir::DataLayoutSpecInterface data_layout_spec(void) const;
-  std::string_view default_dialect(void) const;
-};
-static_assert(sizeof(ModuleOp) == sizeof(Operation));
-
-class MX_EXPORT ScopeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::CORE_SCOPE;
-  }
-
-  static std::optional<ScopeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ScopeOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::core::ScopeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body(void) const;
-};
-static_assert(sizeof(ScopeOp) == sizeof(Operation));
-
-class MX_EXPORT SelectOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::CORE_SELECT;
-  }
-
-  static std::optional<SelectOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SelectOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::core::SelectOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value cond(void) const;
-  ::mx::ir::Value then_region(void) const;
-  ::mx::ir::Value else_region(void) const;
-  gap::generator<::mx::ir::Result> results(void) const &;
-};
-static_assert(sizeof(SelectOp) == sizeof(Operation));
-
-}  // namespace mx::ir::core
diff --git a/include/multiplier/IR/Core/Type.h b/include/multiplier/IR/Core/Type.h
deleted file mode 100644
index 4232d8d81..000000000
--- a/include/multiplier/IR/Core/Type.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Type.h"
-
-namespace vast::core {
-class FunctionType;
-}  // namespace vast::core
-namespace mx::ir::core {
-
-class MX_EXPORT Type : public ::mx::ir::Type {
- public:
-  static std::optional<Type> from(const ::mx::ir::Type &);
-};
-static_assert(sizeof(Type) == sizeof(::mx::ir::Type));
-
-class MX_EXPORT FunctionType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::CORE_FUNCTION;
-  }
-
-  static std::optional<FunctionType> from(const ::mx::ir::Type &that);
-  ::vast::core::FunctionType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool is_var_arg(void) const;
-  unsigned int num_inputs(void) const;
-  unsigned int num_results(void) const;
-  gap::generator<::mx::ir::Type> inputs(void) const &;
-  gap::generator<::mx::ir::Type> results(void) const &;
-  bool var_arg(void) const;
-};
-static_assert(sizeof(FunctionType) == sizeof(Type));
-
-}  // namespace mx::ir::core
diff --git a/include/multiplier/IR/HighLevel/Attribute.h b/include/multiplier/IR/HighLevel/Attribute.h
deleted file mode 100644
index 74696ecf4..000000000
--- a/include/multiplier/IR/HighLevel/Attribute.h
+++ /dev/null
@@ -1,726 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Attribute.h"
-
-namespace vast::hl {
-class AnnotationAttr;
-class FormatAttr;
-class SectionAttr;
-class AliasAttr;
-class ErrorAttr;
-class CountedByAttr;
-class CleanupAttr;
-class AlignedAttr;
-class AlwaysInlineAttr;
-class NoInlineAttr;
-class ConstAttr;
-class LoaderUninitializedAttr;
-class NoInstrumentFunctionAttr;
-class PackedAttr;
-class PureAttr;
-class WarnUnusedResultAttr;
-class RestrictAttr;
-class NoThrowAttr;
-class NonNullAttr;
-class LeafAttr;
-class ColdAttr;
-class TransparentUnionAttr;
-class ReturnsTwiceAttr;
-class MayAliasAttr;
-class UnusedAttr;
-class UsedAttr;
-class GNUInlineAttr;
-class NoCfCheckAttr;
-class AvailableOnlyInDefaultEvalMethodAttr;
-class AvailabilityAttrAttr;
-class FallthroughAttr;
-class NoProfileInstrumentFunctionAttr;
-class AsmLabelAttr;
-class ModeAttr;
-class BuiltinAttr;
-class AllocAlignAttr;
-class AllocSizeAttr;
-class DeprecatedAttr;
-class MaxFieldAlignmentAttr;
-class VisibilityAttr;
-class AssumeAlignedAttr;
-class CVQualifiersAttr;
-class UCVQualifiersAttr;
-class CVRQualifiersAttr;
-class OffsetOfNodeAttr;
-}  // namespace vast::hl
-namespace mx::ir::hl {
-
-class MX_EXPORT Attribute : public ::mx::ir::Attribute {
- public:
-  static std::optional<Attribute> from(const ::mx::ir::Attribute &);
-};
-static_assert(sizeof(Attribute) == sizeof(::mx::ir::Attribute));
-
-class MX_EXPORT AnnotationAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_ANNOTATION;
-  }
-
-  static std::optional<AnnotationAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AnnotationAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::StringAttr name(void) const;
-};
-static_assert(sizeof(AnnotationAttr) == sizeof(Attribute));
-
-class MX_EXPORT FormatAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_FORMAT;
-  }
-
-  static std::optional<FormatAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::FormatAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::StringAttr name(void) const;
-};
-static_assert(sizeof(FormatAttr) == sizeof(Attribute));
-
-class MX_EXPORT SectionAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_SECTION;
-  }
-
-  static std::optional<SectionAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::SectionAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::StringAttr name(void) const;
-};
-static_assert(sizeof(SectionAttr) == sizeof(Attribute));
-
-class MX_EXPORT AliasAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_ALIAS;
-  }
-
-  static std::optional<AliasAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AliasAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::StringAttr name(void) const;
-};
-static_assert(sizeof(AliasAttr) == sizeof(Attribute));
-
-class MX_EXPORT ErrorAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_ERROR;
-  }
-
-  static std::optional<ErrorAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::ErrorAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::StringAttr name(void) const;
-};
-static_assert(sizeof(ErrorAttr) == sizeof(Attribute));
-
-class MX_EXPORT CountedByAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_COUNTED_BY;
-  }
-
-  static std::optional<CountedByAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::CountedByAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::FlatSymbolRefAttr symbol(void) const;
-};
-static_assert(sizeof(CountedByAttr) == sizeof(Attribute));
-
-class MX_EXPORT CleanupAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_CLEANUP;
-  }
-
-  static std::optional<CleanupAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::CleanupAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::SymbolRefAttr symbol(void) const;
-};
-static_assert(sizeof(CleanupAttr) == sizeof(Attribute));
-
-class MX_EXPORT AlignedAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_ALIGNED;
-  }
-
-  static std::optional<AlignedAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AlignedAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(AlignedAttr) == sizeof(Attribute));
-
-class MX_EXPORT AlwaysInlineAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_ALWAYS_INLINE;
-  }
-
-  static std::optional<AlwaysInlineAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AlwaysInlineAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(AlwaysInlineAttr) == sizeof(Attribute));
-
-class MX_EXPORT NoInlineAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_NO_INLINE;
-  }
-
-  static std::optional<NoInlineAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::NoInlineAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(NoInlineAttr) == sizeof(Attribute));
-
-class MX_EXPORT ConstAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_CONST;
-  }
-
-  static std::optional<ConstAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::ConstAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(ConstAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoaderUninitializedAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_LOADER_UNINITIALIZED;
-  }
-
-  static std::optional<LoaderUninitializedAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::LoaderUninitializedAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(LoaderUninitializedAttr) == sizeof(Attribute));
-
-class MX_EXPORT NoInstrumentFunctionAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_NO_INSTRUMENT_FUNCTION;
-  }
-
-  static std::optional<NoInstrumentFunctionAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::NoInstrumentFunctionAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(NoInstrumentFunctionAttr) == sizeof(Attribute));
-
-class MX_EXPORT PackedAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_PACKED;
-  }
-
-  static std::optional<PackedAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::PackedAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(PackedAttr) == sizeof(Attribute));
-
-class MX_EXPORT PureAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_PURE;
-  }
-
-  static std::optional<PureAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::PureAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(PureAttr) == sizeof(Attribute));
-
-class MX_EXPORT WarnUnusedResultAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_WARN_UNUSED_RESULT;
-  }
-
-  static std::optional<WarnUnusedResultAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::WarnUnusedResultAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(WarnUnusedResultAttr) == sizeof(Attribute));
-
-class MX_EXPORT RestrictAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_RESTRICT;
-  }
-
-  static std::optional<RestrictAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::RestrictAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(RestrictAttr) == sizeof(Attribute));
-
-class MX_EXPORT NoThrowAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_NO_THROW;
-  }
-
-  static std::optional<NoThrowAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::NoThrowAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(NoThrowAttr) == sizeof(Attribute));
-
-class MX_EXPORT NonNullAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_NON_NULL;
-  }
-
-  static std::optional<NonNullAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::NonNullAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(NonNullAttr) == sizeof(Attribute));
-
-class MX_EXPORT LeafAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_LEAF;
-  }
-
-  static std::optional<LeafAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::LeafAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(LeafAttr) == sizeof(Attribute));
-
-class MX_EXPORT ColdAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_COLD;
-  }
-
-  static std::optional<ColdAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::ColdAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(ColdAttr) == sizeof(Attribute));
-
-class MX_EXPORT TransparentUnionAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_TRANSPARENT_UNION;
-  }
-
-  static std::optional<TransparentUnionAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::TransparentUnionAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(TransparentUnionAttr) == sizeof(Attribute));
-
-class MX_EXPORT ReturnsTwiceAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_RETURNS_TWICE;
-  }
-
-  static std::optional<ReturnsTwiceAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::ReturnsTwiceAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(ReturnsTwiceAttr) == sizeof(Attribute));
-
-class MX_EXPORT MayAliasAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_MAY_ALIAS;
-  }
-
-  static std::optional<MayAliasAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::MayAliasAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(MayAliasAttr) == sizeof(Attribute));
-
-class MX_EXPORT UnusedAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_UNUSED;
-  }
-
-  static std::optional<UnusedAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::UnusedAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(UnusedAttr) == sizeof(Attribute));
-
-class MX_EXPORT UsedAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_USED;
-  }
-
-  static std::optional<UsedAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::UsedAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(UsedAttr) == sizeof(Attribute));
-
-class MX_EXPORT GNUInlineAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_GNU_INLINE;
-  }
-
-  static std::optional<GNUInlineAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::GNUInlineAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(GNUInlineAttr) == sizeof(Attribute));
-
-class MX_EXPORT NoCfCheckAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_NO_CF_CHECK;
-  }
-
-  static std::optional<NoCfCheckAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::NoCfCheckAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(NoCfCheckAttr) == sizeof(Attribute));
-
-class MX_EXPORT AvailableOnlyInDefaultEvalMethodAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_AVAILABLE_ONLY_IN_DEFAULT_EVAL_METHOD;
-  }
-
-  static std::optional<AvailableOnlyInDefaultEvalMethodAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AvailableOnlyInDefaultEvalMethodAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(AvailableOnlyInDefaultEvalMethodAttr) == sizeof(Attribute));
-
-class MX_EXPORT AvailabilityAttrAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_AVAILABILITY_ATTR;
-  }
-
-  static std::optional<AvailabilityAttrAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AvailabilityAttrAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(AvailabilityAttrAttr) == sizeof(Attribute));
-
-class MX_EXPORT FallthroughAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_FALLTHROUGH;
-  }
-
-  static std::optional<FallthroughAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::FallthroughAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(FallthroughAttr) == sizeof(Attribute));
-
-class MX_EXPORT NoProfileInstrumentFunctionAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_NO_PROFILE_INSTRUMENT_FUNCTION;
-  }
-
-  static std::optional<NoProfileInstrumentFunctionAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::NoProfileInstrumentFunctionAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(NoProfileInstrumentFunctionAttr) == sizeof(Attribute));
-
-class MX_EXPORT AsmLabelAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_ASM_LABEL;
-  }
-
-  static std::optional<AsmLabelAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AsmLabelAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::StringAttr label(void) const;
-  bool is_literal(void) const;
-};
-static_assert(sizeof(AsmLabelAttr) == sizeof(Attribute));
-
-class MX_EXPORT ModeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_MODE;
-  }
-
-  static std::optional<ModeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::ModeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::StringAttr mode(void) const;
-};
-static_assert(sizeof(ModeAttr) == sizeof(Attribute));
-
-class MX_EXPORT BuiltinAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_BUILTIN;
-  }
-
-  static std::optional<BuiltinAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::BuiltinAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int id(void) const;
-};
-static_assert(sizeof(BuiltinAttr) == sizeof(Attribute));
-
-class MX_EXPORT AllocAlignAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_ALLOC_ALIGN;
-  }
-
-  static std::optional<AllocAlignAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AllocAlignAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  int alignment(void) const;
-};
-static_assert(sizeof(AllocAlignAttr) == sizeof(Attribute));
-
-class MX_EXPORT AllocSizeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_ALLOC_SIZE;
-  }
-
-  static std::optional<AllocSizeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AllocSizeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  int size_arg_pos(void) const;
-  int num_arg_pos(void) const;
-};
-static_assert(sizeof(AllocSizeAttr) == sizeof(Attribute));
-
-class MX_EXPORT DeprecatedAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_DEPRECATED;
-  }
-
-  static std::optional<DeprecatedAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::DeprecatedAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::StringAttr message(void) const;
-  //::mlir::StringAttr fixit(void) const;
-};
-static_assert(sizeof(DeprecatedAttr) == sizeof(Attribute));
-
-class MX_EXPORT MaxFieldAlignmentAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_MAX_FIELD_ALIGNMENT;
-  }
-
-  static std::optional<MaxFieldAlignmentAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::MaxFieldAlignmentAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int alignment(void) const;
-};
-static_assert(sizeof(MaxFieldAlignmentAttr) == sizeof(Attribute));
-
-class MX_EXPORT VisibilityAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_VISIBILITY;
-  }
-
-  static std::optional<VisibilityAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::VisibilityAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::vast::hl::Visibility value(void) const;
-};
-static_assert(sizeof(VisibilityAttr) == sizeof(Attribute));
-
-class MX_EXPORT AssumeAlignedAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_ASSUME_ALIGNED;
-  }
-
-  static std::optional<AssumeAlignedAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::AssumeAlignedAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //llvm::APInt alignment(void) const;
-  //llvm::APInt offset(void) const;
-};
-static_assert(sizeof(AssumeAlignedAttr) == sizeof(Attribute));
-
-class MX_EXPORT CVQualifiersAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_CV_QUALIFIERS;
-  }
-
-  static std::optional<CVQualifiersAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::CVQualifiersAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool is_const(void) const;
-  bool is_volatile(void) const;
-};
-static_assert(sizeof(CVQualifiersAttr) == sizeof(Attribute));
-
-class MX_EXPORT UCVQualifiersAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_UCV_QUALIFIERS;
-  }
-
-  static std::optional<UCVQualifiersAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::UCVQualifiersAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool is_unsigned(void) const;
-  bool is_const(void) const;
-  bool is_volatile(void) const;
-};
-static_assert(sizeof(UCVQualifiersAttr) == sizeof(Attribute));
-
-class MX_EXPORT CVRQualifiersAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_CVR_QUALIFIERS;
-  }
-
-  static std::optional<CVRQualifiersAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::CVRQualifiersAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool is_const(void) const;
-  bool is_volatile(void) const;
-  bool is_restrict(void) const;
-};
-static_assert(sizeof(CVRQualifiersAttr) == sizeof(Attribute));
-
-class MX_EXPORT OffsetOfNodeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::HL_OFFSET_OF_NODE;
-  }
-
-  static std::optional<OffsetOfNodeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::hl::OffsetOfNodeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //std::variant<unsigned int, StringAttr> value(void) const;
-};
-static_assert(sizeof(OffsetOfNodeAttr) == sizeof(Attribute));
-
-}  // namespace mx::ir::hl
diff --git a/include/multiplier/IR/HighLevel/Dialect.h b/include/multiplier/IR/HighLevel/Dialect.h
deleted file mode 100644
index cdb370293..000000000
--- a/include/multiplier/IR/HighLevel/Dialect.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "Attribute.h"
-#include "Type.h"
-#include "Operation.h"
diff --git a/include/multiplier/IR/HighLevel/Operation.h b/include/multiplier/IR/HighLevel/Operation.h
deleted file mode 100644
index 7b1229114..000000000
--- a/include/multiplier/IR/HighLevel/Operation.h
+++ /dev/null
@@ -1,2494 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Operation.h"
-
-namespace vast::hl {
-class AccessSpecifierOp;
-class AddFAssignOp;
-class AddFOp;
-class AddIAssignOp;
-class AddIOp;
-class AddrLabelExpr;
-class AddressOf;
-class AlignOfExprOp;
-class AlignOfTypeOp;
-class AsmOp;
-class AssignOp;
-class AttributedStmt;
-class BinAShrAssignOp;
-class BinAShrOp;
-class BinAndAssignOp;
-class BinAndOp;
-class BinComma;
-class BinLAndOp;
-class BinLOrOp;
-class BinLShrAssignOp;
-class BinLShrOp;
-class BinOrAssignOp;
-class BinOrOp;
-class BinShlAssignOp;
-class BinShlOp;
-class BinXorAssignOp;
-class BinXorOp;
-class BinaryCondOp;
-class BreakOp;
-class BuiltinBitCastOp;
-class BuiltinTypesCompatiblePOp;
-class CStyleCastOp;
-class CallOp;
-class CaseOp;
-class ChooseExprOp;
-class ClassDeclOp;
-class CmpOp;
-class CompoundLiteralOp;
-class CondOp;
-class CondYieldOp;
-class ConstantOp;
-class ContinueOp;
-class CxxBaseSpecifierOp;
-class CxxStructDeclOp;
-class DeclRefOp;
-class DefaultOp;
-class Deref;
-class DivFAssignOp;
-class DivFOp;
-class DivSAssignOp;
-class DivSOp;
-class DivUAssignOp;
-class DivUOp;
-class DoOp;
-class EmptyDeclOp;
-class EnumConstantOp;
-class EnumDeclOp;
-class EnumRefOp;
-class ExprOp;
-class ExtensionOp;
-class FCmpOp;
-class FieldDeclOp;
-class FileScopeAsmOp;
-class ForOp;
-class FuncOp;
-class FuncRefOp;
-class GenericAssocExpr;
-class GenericSelectionExpr;
-class GlobalRefOp;
-class GotoStmt;
-class IfOp;
-class ImagOp;
-class ImplicitCastOp;
-class IndirectCallOp;
-class IndirectGotoStmt;
-class InitListExpr;
-class InitializedConstantOp;
-class LNotOp;
-class LabelDeclOp;
-class LabelStmt;
-class MinusOp;
-class MulFAssignOp;
-class MulFOp;
-class MulIAssignOp;
-class MulIOp;
-class NotOp;
-class NullStmt;
-class OffsetOfExprOp;
-class OpaqueValueExpr;
-class PlusOp;
-class PostDecOp;
-class PostIncOp;
-class PreDecOp;
-class PreIncOp;
-class PredefinedExpr;
-class PreferredAlignOfExprOp;
-class PreferredAlignOfTypeOp;
-class RealOp;
-class RecordMemberOp;
-class RemFAssignOp;
-class RemFOp;
-class RemSAssignOp;
-class RemSOp;
-class RemUAssignOp;
-class RemUOp;
-class ReturnOp;
-class SizeOfExprOp;
-class SizeOfTypeOp;
-class StaticAssertDecl;
-class StmtExprOp;
-class StructDeclOp;
-class SubFAssignOp;
-class SubFOp;
-class SubIAssignOp;
-class SubIOp;
-class SubscriptOp;
-class SwitchOp;
-class ThisOp;
-class TranslationUnitOp;
-class TypeAliasOp;
-class TypeDeclOp;
-class TypeDefOp;
-class TypeOfExprOp;
-class TypeYieldOp;
-class UnionDeclOp;
-class UnreachableOp;
-class VAArgExpr;
-class ValueYieldOp;
-class VarDeclOp;
-class WhileOp;
-}  // namespace vast::hl
-namespace mx::ir::hl {
-
-class MX_EXPORT Operation : public ::mx::ir::Operation {
- public:
-  static std::optional<Operation> from(const ::mx::ir::Operation &);
-};
-static_assert(sizeof(Operation) == sizeof(::mx::ir::Operation));
-
-class MX_EXPORT RefOp : public Operation {
- public:
-  static std::optional<RefOp> from(const ::mx::ir::Operation &);
-  std::optional<Symbol> referenced_symbol(void) const noexcept;
-};
-static_assert(sizeof(RefOp) == sizeof(Operation));
-
-class MX_EXPORT AccessSpecifierOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ACCESS;
-  }
-
-  static std::optional<AccessSpecifierOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AccessSpecifierOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AccessSpecifierOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::vast::hl::AccessSpecifier spec(void) const;
-};
-static_assert(sizeof(AccessSpecifierOp) == sizeof(Operation));
-
-class MX_EXPORT AddFAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_FADD;
-  }
-
-  static std::optional<AddFAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AddFAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AddFAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AddFAssignOp) == sizeof(Operation));
-
-class MX_EXPORT AddFOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FADD;
-  }
-
-  static std::optional<AddFOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AddFOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AddFOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AddFOp) == sizeof(Operation));
-
-class MX_EXPORT AddIAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_ADD;
-  }
-
-  static std::optional<AddIAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AddIAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AddIAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AddIAssignOp) == sizeof(Operation));
-
-class MX_EXPORT AddIOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ADD;
-  }
-
-  static std::optional<AddIOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AddIOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AddIOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AddIOp) == sizeof(Operation));
-
-class MX_EXPORT AddrLabelExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_LABELADDR;
-  }
-
-  static std::optional<AddrLabelExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AddrLabelExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AddrLabelExpr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value label(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AddrLabelExprOp) == sizeof(Operation));
-
-class MX_EXPORT AddressOfOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ADDRESSOF;
-  }
-
-  static std::optional<AddressOfOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AddressOfOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AddressOf underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AddressOfOp) == sizeof(Operation));
-
-class MX_EXPORT AlignOfExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ALIGNOF_EXPR;
-  }
-
-  static std::optional<AlignOfExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AlignOfExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AlignOfExprOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region expression(void) const;
-};
-static_assert(sizeof(AlignOfExprOp) == sizeof(Operation));
-
-class MX_EXPORT AlignOfTypeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ALIGNOF_TYPE;
-  }
-
-  static std::optional<AlignOfTypeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AlignOfTypeOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AlignOfTypeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Type argument(void) const;
-};
-static_assert(sizeof(AlignOfTypeOp) == sizeof(Operation));
-
-class MX_EXPORT AsmOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASM;
-  }
-
-  static std::optional<AsmOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AsmOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AsmOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> asm_outputs(void) const &;
-  gap::generator<::mx::ir::Operand> asm_inputs(void) const &;
-  gap::generator<::mx::ir::Operand> labels(void) const &;
-  std::string_view asm_template(void) const;
-  bool is_volatile(void) const;
-  bool has_goto(void) const;
-  //::std::optional<ArrayAttr> output_names(void) const;
-  //::std::optional<ArrayAttr> input_names(void) const;
-  //::std::optional<ArrayAttr> output_constraints(void) const;
-  //::std::optional<ArrayAttr> input_constraints(void) const;
-  //::std::optional<ArrayAttr> clobbers(void) const;
-};
-static_assert(sizeof(AsmOp) == sizeof(Operation));
-
-class MX_EXPORT AssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN;
-  }
-
-  static std::optional<AssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AssignOp) == sizeof(Operation));
-
-class MX_EXPORT AttributedStmtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ATTRIBUTED_STMT;
-  }
-
-  static std::optional<AttributedStmtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AttributedStmtOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::AttributedStmt underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body(void) const;
-};
-static_assert(sizeof(AttributedStmtOp) == sizeof(Operation));
-
-class MX_EXPORT BinAShrAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_BIN_ASHR;
-  }
-
-  static std::optional<BinAShrAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinAShrAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinAShrAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinAShrAssignOp) == sizeof(Operation));
-
-class MX_EXPORT BinAShrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BIN_ASHR;
-  }
-
-  static std::optional<BinAShrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinAShrOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinAShrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinAShrOp) == sizeof(Operation));
-
-class MX_EXPORT BinAndAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_BIN_AND;
-  }
-
-  static std::optional<BinAndAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinAndAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinAndAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinAndAssignOp) == sizeof(Operation));
-
-class MX_EXPORT BinAndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BIN_AND;
-  }
-
-  static std::optional<BinAndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinAndOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinAndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinAndOp) == sizeof(Operation));
-
-class MX_EXPORT BinCommaOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BIN_COMMA;
-  }
-
-  static std::optional<BinCommaOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinCommaOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinComma underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinCommaOp) == sizeof(Operation));
-
-class MX_EXPORT BinLAndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BIN_LAND;
-  }
-
-  static std::optional<BinLAndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinLAndOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinLAndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region left(void) const;
-  ::mx::ir::Region right(void) const;
-};
-static_assert(sizeof(BinLAndOp) == sizeof(Operation));
-
-class MX_EXPORT BinLOrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BIN_LOR;
-  }
-
-  static std::optional<BinLOrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinLOrOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinLOrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region left(void) const;
-  ::mx::ir::Region right(void) const;
-};
-static_assert(sizeof(BinLOrOp) == sizeof(Operation));
-
-class MX_EXPORT BinLShrAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_BIN_LSHR;
-  }
-
-  static std::optional<BinLShrAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinLShrAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinLShrAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinLShrAssignOp) == sizeof(Operation));
-
-class MX_EXPORT BinLShrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BIN_LSHR;
-  }
-
-  static std::optional<BinLShrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinLShrOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinLShrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinLShrOp) == sizeof(Operation));
-
-class MX_EXPORT BinOrAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_BIN_OR;
-  }
-
-  static std::optional<BinOrAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinOrAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinOrAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinOrAssignOp) == sizeof(Operation));
-
-class MX_EXPORT BinOrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BIN_OR;
-  }
-
-  static std::optional<BinOrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinOrOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinOrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinOrOp) == sizeof(Operation));
-
-class MX_EXPORT BinShlAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_BIN_SHL;
-  }
-
-  static std::optional<BinShlAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinShlAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinShlAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinShlAssignOp) == sizeof(Operation));
-
-class MX_EXPORT BinShlOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BIN_SHL;
-  }
-
-  static std::optional<BinShlOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinShlOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinShlOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinShlOp) == sizeof(Operation));
-
-class MX_EXPORT BinXorAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_BIN_XOR;
-  }
-
-  static std::optional<BinXorAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinXorAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinXorAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinXorAssignOp) == sizeof(Operation));
-
-class MX_EXPORT BinXorOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BIN_XOR;
-  }
-
-  static std::optional<BinXorOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinXorOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinXorOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BinXorOp) == sizeof(Operation));
-
-class MX_EXPORT BinaryCondOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BINARY_COND;
-  }
-
-  static std::optional<BinaryCondOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BinaryCondOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BinaryCondOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  std::optional<::mx::ir::Region> common_region(void) const;
-  ::mx::ir::Region condition_region(void) const;
-  ::mx::ir::Region then_region(void) const;
-  ::mx::ir::Region else_region(void) const;
-};
-static_assert(sizeof(BinaryCondOp) == sizeof(Operation));
-
-class MX_EXPORT BreakOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BREAK;
-  }
-
-  static std::optional<BreakOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BreakOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BreakOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(BreakOp) == sizeof(Operation));
-
-class MX_EXPORT BuiltinBitCastOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BUILTIN_BITCAST;
-  }
-
-  static std::optional<BuiltinBitCastOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BuiltinBitCastOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BuiltinBitCastOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-  //::vast::hl::CastKind kind(void) const;
-};
-static_assert(sizeof(BuiltinBitCastOp) == sizeof(Operation));
-
-class MX_EXPORT BuiltinTypesCompatiblePOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BUILTIN_TYPES_COMPATIBLE_P_TYPE;
-  }
-
-  static std::optional<BuiltinTypesCompatiblePOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BuiltinTypesCompatiblePOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::BuiltinTypesCompatiblePOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Type type1(void) const;
-  ::mx::ir::Type type2(void) const;
-  bool compatible(void) const;
-  gap::generator<::mx::ir::Type> arguments(void) const &;
-  std::optional<bool> value(void) const;
-};
-static_assert(sizeof(BuiltinTypesCompatiblePOp) == sizeof(Operation));
-
-class MX_EXPORT CStyleCastOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CSTYLE_CAST;
-  }
-
-  static std::optional<CStyleCastOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CStyleCastOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::CStyleCastOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-  //::vast::hl::CastKind kind(void) const;
-};
-static_assert(sizeof(CStyleCastOp) == sizeof(Operation));
-
-class MX_EXPORT CallOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CALL;
-  }
-
-  static std::optional<CallOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CallOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::CallOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> arg_operands(void) const &;
-  gap::generator<::mx::ir::Result> results(void) const &;
-  std::string_view callee(void) const;
-  //::mlir::CallInterfaceCallable callable_for_callee(void) const;
-  //::mlir::Operation * resolve_callable(void) const;
-};
-static_assert(sizeof(CallOp) == sizeof(Operation));
-
-class MX_EXPORT CaseOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CASE;
-  }
-
-  static std::optional<CaseOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CaseOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::CaseOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region left(void) const;
-  std::optional<::mx::ir::Region> body(void) const;
-};
-static_assert(sizeof(CaseOp) == sizeof(Operation));
-
-class MX_EXPORT ChooseExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CHOOSE_EXPR;
-  }
-
-  static std::optional<ChooseExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ChooseExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ChooseExprOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region condition_region(void) const;
-  ::mx::ir::Region then_region(void) const;
-  ::mx::ir::Region else_region(void) const;
-  std::optional<bool> cond_true(void) const;
-  std::optional<bool> is_condition_true(void) const;
-  bool is_condition_dependent(void) const;
-  //region_ptr chosen_sub_expr(void) const;
-};
-static_assert(sizeof(ChooseExprOp) == sizeof(Operation));
-
-class MX_EXPORT ClassDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CLASS;
-  }
-
-  static std::optional<ClassDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ClassDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ClassDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region bases(void) const;
-  ::mx::ir::Region fields(void) const;
-  std::string_view name(void) const;
-};
-static_assert(sizeof(ClassDeclOp) == sizeof(Operation));
-
-class MX_EXPORT CmpOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CMP;
-  }
-
-  static std::optional<CmpOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CmpOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::CmpOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::vast::hl::Predicate predicate(void) const;
-};
-static_assert(sizeof(CmpOp) == sizeof(Operation));
-
-class MX_EXPORT CompoundLiteralOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_COMPOUND_LITERAL;
-  }
-
-  static std::optional<CompoundLiteralOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CompoundLiteralOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::CompoundLiteralOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region initializer(void) const;
-};
-static_assert(sizeof(CompoundLiteralOp) == sizeof(Operation));
-
-class MX_EXPORT CondOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_COND;
-  }
-
-  static std::optional<CondOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CondOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::CondOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region condition_region(void) const;
-  ::mx::ir::Region then_region(void) const;
-  ::mx::ir::Region else_region(void) const;
-};
-static_assert(sizeof(CondOp) == sizeof(Operation));
-
-class MX_EXPORT CondYieldOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_COND_YIELD;
-  }
-
-  static std::optional<CondYieldOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CondYieldOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::CondYieldOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CondYieldOp) == sizeof(Operation));
-
-class MX_EXPORT ConstantOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CONST;
-  }
-
-  static std::optional<ConstantOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ConstantOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ConstantOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  //::mlir::TypedAttr value(void) const;
-};
-static_assert(sizeof(ConstantOp) == sizeof(Operation));
-
-class MX_EXPORT ContinueOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CONTINUE;
-  }
-
-  static std::optional<ContinueOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ContinueOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ContinueOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(ContinueOp) == sizeof(Operation));
-
-class MX_EXPORT CxxBaseSpecifierOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_BASE;
-  }
-
-  static std::optional<CxxBaseSpecifierOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CxxBaseSpecifierOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::CxxBaseSpecifierOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Type type(void) const;
-  //::vast::hl::AccessSpecifier access(void) const;
-  bool is_virtual(void) const;
-};
-static_assert(sizeof(CxxBaseSpecifierOp) == sizeof(Operation));
-
-class MX_EXPORT CxxStructDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CXXSTRUCT;
-  }
-
-  static std::optional<CxxStructDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CxxStructDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::CxxStructDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region bases(void) const;
-  ::mx::ir::Region fields(void) const;
-  std::string_view name(void) const;
-};
-static_assert(sizeof(CxxStructDeclOp) == sizeof(Operation));
-
-class MX_EXPORT DeclRefOp final : public RefOp {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_REF;
-  }
-
-  static std::optional<DeclRefOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DeclRefOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::DeclRefOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value declaration(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(DeclRefOp) == sizeof(Operation));
-
-class MX_EXPORT DefaultOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_DEFAULT;
-  }
-
-  static std::optional<DefaultOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DefaultOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::DefaultOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::optional<::mx::ir::Region> body(void) const;
-};
-static_assert(sizeof(DefaultOp) == sizeof(Operation));
-
-class MX_EXPORT DerefOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_DEREF;
-  }
-
-  static std::optional<DerefOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DerefOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::Deref underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value addr(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(DerefOp) == sizeof(Operation));
-
-class MX_EXPORT DivFAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_FDIV;
-  }
-
-  static std::optional<DivFAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DivFAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::DivFAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(DivFAssignOp) == sizeof(Operation));
-
-class MX_EXPORT DivFOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FDIV;
-  }
-
-  static std::optional<DivFOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DivFOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::DivFOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(DivFOp) == sizeof(Operation));
-
-class MX_EXPORT DivSAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_SDIV;
-  }
-
-  static std::optional<DivSAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DivSAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::DivSAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(DivSAssignOp) == sizeof(Operation));
-
-class MX_EXPORT DivSOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_SDIV;
-  }
-
-  static std::optional<DivSOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DivSOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::DivSOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(DivSOp) == sizeof(Operation));
-
-class MX_EXPORT DivUAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_UDIV;
-  }
-
-  static std::optional<DivUAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DivUAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::DivUAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(DivUAssignOp) == sizeof(Operation));
-
-class MX_EXPORT DivUOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_UDIV;
-  }
-
-  static std::optional<DivUOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DivUOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::DivUOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(DivUOp) == sizeof(Operation));
-
-class MX_EXPORT DoOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_DO;
-  }
-
-  static std::optional<DoOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DoOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::DoOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body_region(void) const;
-  ::mx::ir::Region condition_region(void) const;
-};
-static_assert(sizeof(DoOp) == sizeof(Operation));
-
-class MX_EXPORT EmptyDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_EMPTY_DECL;
-  }
-
-  static std::optional<EmptyDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<EmptyDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::EmptyDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(EmptyDeclOp) == sizeof(Operation));
-
-class MX_EXPORT EnumConstantOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ENUM_CONST;
-  }
-
-  static std::optional<EnumConstantOp> from(const ::mx::ir::Operation &that);
-  static std::optional<EnumConstantOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::EnumConstantOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region initializer(void) const;
-  std::string_view name(void) const;
-  //::mlir::TypedAttr value(void) const;
-};
-static_assert(sizeof(EnumConstantOp) == sizeof(Operation));
-
-class MX_EXPORT EnumDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ENUM;
-  }
-
-  static std::optional<EnumDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<EnumDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::EnumDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region constants(void) const;
-  std::string_view name(void) const;
-  std::optional<::mx::ir::Type> type(void) const;
-  bool is_complete(void) const;
-  ::mx::ir::Block constants_block(void) const;
-};
-static_assert(sizeof(EnumDeclOp) == sizeof(Operation));
-
-class MX_EXPORT EnumRefOp final : public RefOp {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ENUMREF;
-  }
-
-  static std::optional<EnumRefOp> from(const ::mx::ir::Operation &that);
-  static std::optional<EnumRefOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::EnumRefOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  std::string_view value(void) const;
-};
-static_assert(sizeof(EnumRefOp) == sizeof(Operation));
-
-class MX_EXPORT ExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_EXPR;
-  }
-
-  static std::optional<ExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ExprOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region nested_expression(void) const;
-};
-static_assert(sizeof(ExprOp) == sizeof(Operation));
-
-class MX_EXPORT ExtensionOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_GNU_EXTENSION;
-  }
-
-  static std::optional<ExtensionOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExtensionOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ExtensionOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ExtensionOp) == sizeof(Operation));
-
-class MX_EXPORT FCmpOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FCMP;
-  }
-
-  static std::optional<FCmpOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FCmpOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::FCmpOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::vast::hl::FPredicate predicate(void) const;
-};
-static_assert(sizeof(FCmpOp) == sizeof(Operation));
-
-class MX_EXPORT FieldDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FIELD;
-  }
-
-  static std::optional<FieldDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FieldDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::FieldDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  ::mx::ir::Type type(void) const;
-  std::optional<unsigned int> bits(void) const;
-  //vast::core::aggregate_interface aggregate(void) const;
-};
-static_assert(sizeof(FieldDeclOp) == sizeof(Operation));
-
-class MX_EXPORT FileScopeAsmOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FILE_SCOPE_ASM;
-  }
-
-  static std::optional<FileScopeAsmOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FileScopeAsmOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::FileScopeAsmOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view assembly(void) const;
-};
-static_assert(sizeof(FileScopeAsmOp) == sizeof(Operation));
-
-class MX_EXPORT ForOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FOR;
-  }
-
-  static std::optional<ForOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ForOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ForOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region condition_region(void) const;
-  std::optional<::mx::ir::Region> incr_region(void) const;
-  std::optional<::mx::ir::Region> body_region(void) const;
-};
-static_assert(sizeof(ForOp) == sizeof(Operation));
-
-class MX_EXPORT FuncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FUNC;
-  }
-
-  static std::optional<FuncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FuncOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::FuncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::optional<::mx::ir::Region> body(void) const;
-  std::string_view name(void) const;
-  ::mx::ir::Type function_type(void) const;
-  //::std::optional<GlobalLinkageKind> linkage(void) const;
-  std::optional<std::string_view> visibility(void) const;
-  //::std::optional<ArrayAttr> arg_attrs(void) const;
-  //::std::optional<ArrayAttr> res_attrs(void) const;
-  bool is_var_arg(void) const;
-  //::mlir::Region * callable_region(void) const;
-  gap::generator<::mx::ir::Type> callable_results(void) const &;
-  //::mlir::ArrayAttr callable_arg_attrs(void) const;
-  //::mlir::ArrayAttr callable_res_attrs(void) const;
-  gap::generator<::mx::ir::Type> argument_types(void) const &;
-  gap::generator<::mx::ir::Type> result_types(void) const &;
-  bool is_declaration(void) const;
-};
-static_assert(sizeof(FuncOp) == sizeof(Operation));
-
-class MX_EXPORT FuncRefOp final : public RefOp {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FUNCREF;
-  }
-
-  static std::optional<FuncRefOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FuncRefOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::FuncRefOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  std::string_view function(void) const;
-};
-static_assert(sizeof(FuncRefOp) == sizeof(Operation));
-
-class MX_EXPORT GenericAssocExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_GENERIC_ASOC;
-  }
-
-  static std::optional<GenericAssocExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GenericAssocExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::GenericAssocExpr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region body(void) const;
-  std::optional<::mx::ir::Type> match_type(void) const;
-};
-static_assert(sizeof(GenericAssocExprOp) == sizeof(Operation));
-
-class MX_EXPORT GenericSelectionExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_GENERIC_EXPR;
-  }
-
-  static std::optional<GenericSelectionExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GenericSelectionExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::GenericSelectionExpr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region control(void) const;
-  ::mx::ir::Region body(void) const;
-  std::optional<::mx::ir::Type> control_type(void) const;
-  //::std::optional<APInt> selected(void) const;
-  //std::optional<Region *> result_region(void) const;
-  bool is_expression_predicate(void) const;
-  bool is_type_predicate(void) const;
-};
-static_assert(sizeof(GenericSelectionExprOp) == sizeof(Operation));
-
-class MX_EXPORT GlobalRefOp final : public RefOp {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_GLOBREF;
-  }
-
-  static std::optional<GlobalRefOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GlobalRefOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::GlobalRefOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  std::string_view global(void) const;
-};
-static_assert(sizeof(GlobalRefOp) == sizeof(Operation));
-
-class MX_EXPORT GotoStmtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_GOTO;
-  }
-
-  static std::optional<GotoStmtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GotoStmtOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::GotoStmt underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value label(void) const;
-};
-static_assert(sizeof(GotoStmtOp) == sizeof(Operation));
-
-class MX_EXPORT IfOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_IF;
-  }
-
-  static std::optional<IfOp> from(const ::mx::ir::Operation &that);
-  static std::optional<IfOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::IfOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region condition_region(void) const;
-  ::mx::ir::Region then_region(void) const;
-  std::optional<::mx::ir::Region> else_region(void) const;
-  bool has_else(void) const;
-};
-static_assert(sizeof(IfOp) == sizeof(Operation));
-
-class MX_EXPORT ImagOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_IMAG;
-  }
-
-  static std::optional<ImagOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ImagOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ImagOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ImagOp) == sizeof(Operation));
-
-class MX_EXPORT ImplicitCastOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_IMPLICIT_CAST;
-  }
-
-  static std::optional<ImplicitCastOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ImplicitCastOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ImplicitCastOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-  //::vast::hl::CastKind kind(void) const;
-};
-static_assert(sizeof(ImplicitCastOp) == sizeof(Operation));
-
-class MX_EXPORT IndirectCallOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_INDIRECT_CALL;
-  }
-
-  static std::optional<IndirectCallOp> from(const ::mx::ir::Operation &that);
-  static std::optional<IndirectCallOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::IndirectCallOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value callee(void) const;
-  gap::generator<::mx::ir::Operand> arg_operands(void) const &;
-  gap::generator<::mx::ir::Result> results(void) const &;
-  //::mlir::CallInterfaceCallable callable_for_callee(void) const;
-};
-static_assert(sizeof(IndirectCallOp) == sizeof(Operation));
-
-class MX_EXPORT IndirectGotoStmtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_INDIRECT_GOTO;
-  }
-
-  static std::optional<IndirectGotoStmtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<IndirectGotoStmtOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::IndirectGotoStmt underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region target(void) const;
-};
-static_assert(sizeof(IndirectGotoStmtOp) == sizeof(Operation));
-
-class MX_EXPORT InitListExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_INITLIST;
-  }
-
-  static std::optional<InitListExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InitListExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::InitListExpr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> elements(void) const &;
-};
-static_assert(sizeof(InitListExprOp) == sizeof(Operation));
-
-class MX_EXPORT InitializedConstantOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_CONST_INIT;
-  }
-
-  static std::optional<InitializedConstantOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InitializedConstantOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::InitializedConstantOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region initializer(void) const;
-};
-static_assert(sizeof(InitializedConstantOp) == sizeof(Operation));
-
-class MX_EXPORT LNotOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_LNOT;
-  }
-
-  static std::optional<LNotOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LNotOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::LNotOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(LNotOp) == sizeof(Operation));
-
-class MX_EXPORT LabelDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_LABEL_DECL;
-  }
-
-  static std::optional<LabelDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LabelDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::LabelDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  std::string_view name(void) const;
-};
-static_assert(sizeof(LabelDeclOp) == sizeof(Operation));
-
-class MX_EXPORT LabelStmtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_LABEL;
-  }
-
-  static std::optional<LabelStmtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LabelStmtOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::LabelStmt underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value label(void) const;
-  ::mx::ir::Region body(void) const;
-};
-static_assert(sizeof(LabelStmtOp) == sizeof(Operation));
-
-class MX_EXPORT MinusOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_MINUS;
-  }
-
-  static std::optional<MinusOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MinusOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::MinusOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(MinusOp) == sizeof(Operation));
-
-class MX_EXPORT MulFAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_FMUL;
-  }
-
-  static std::optional<MulFAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MulFAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::MulFAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(MulFAssignOp) == sizeof(Operation));
-
-class MX_EXPORT MulFOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FMUL;
-  }
-
-  static std::optional<MulFOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MulFOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::MulFOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(MulFOp) == sizeof(Operation));
-
-class MX_EXPORT MulIAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_MUL;
-  }
-
-  static std::optional<MulIAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MulIAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::MulIAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(MulIAssignOp) == sizeof(Operation));
-
-class MX_EXPORT MulIOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_MUL;
-  }
-
-  static std::optional<MulIOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MulIOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::MulIOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(MulIOp) == sizeof(Operation));
-
-class MX_EXPORT NotOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_NOT;
-  }
-
-  static std::optional<NotOp> from(const ::mx::ir::Operation &that);
-  static std::optional<NotOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::NotOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(NotOp) == sizeof(Operation));
-
-class MX_EXPORT NullStmtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_NULL;
-  }
-
-  static std::optional<NullStmtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<NullStmtOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::NullStmt underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(NullStmtOp) == sizeof(Operation));
-
-class MX_EXPORT OffsetOfExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_OFFSETOF_EXPR;
-  }
-
-  static std::optional<OffsetOfExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<OffsetOfExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::OffsetOfExprOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  gap::generator<::mx::ir::Region> array_index_exprs(void) const &;
-  ::mx::ir::Type source(void) const;
-  //::mlir::ArrayAttr components(void) const;
-};
-static_assert(sizeof(OffsetOfExprOp) == sizeof(Operation));
-
-class MX_EXPORT OpaqueValueExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_OPAQUE_EXPR;
-  }
-
-  static std::optional<OpaqueValueExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<OpaqueValueExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::OpaqueValueExpr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> argument(void) const &;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(OpaqueValueExprOp) == sizeof(Operation));
-
-class MX_EXPORT PlusOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_PLUS;
-  }
-
-  static std::optional<PlusOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PlusOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::PlusOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(PlusOp) == sizeof(Operation));
-
-class MX_EXPORT PostDecOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_POST_DEC;
-  }
-
-  static std::optional<PostDecOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PostDecOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::PostDecOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(PostDecOp) == sizeof(Operation));
-
-class MX_EXPORT PostIncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_POST_INC;
-  }
-
-  static std::optional<PostIncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PostIncOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::PostIncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(PostIncOp) == sizeof(Operation));
-
-class MX_EXPORT PreDecOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_PRE_DEC;
-  }
-
-  static std::optional<PreDecOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PreDecOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::PreDecOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(PreDecOp) == sizeof(Operation));
-
-class MX_EXPORT PreIncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_PRE_INC;
-  }
-
-  static std::optional<PreIncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PreIncOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::PreIncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(PreIncOp) == sizeof(Operation));
-
-class MX_EXPORT PredefinedExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_PREDEFINED_EXPR;
-  }
-
-  static std::optional<PredefinedExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PredefinedExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::PredefinedExpr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-  //::vast::hl::IdentKind kind(void) const;
-};
-static_assert(sizeof(PredefinedExprOp) == sizeof(Operation));
-
-class MX_EXPORT PreferredAlignOfExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_PREFERRED_ALIGNOF_EXPR;
-  }
-
-  static std::optional<PreferredAlignOfExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PreferredAlignOfExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::PreferredAlignOfExprOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region expression(void) const;
-};
-static_assert(sizeof(PreferredAlignOfExprOp) == sizeof(Operation));
-
-class MX_EXPORT PreferredAlignOfTypeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_PREFERRED_ALIGNOF_TYPE;
-  }
-
-  static std::optional<PreferredAlignOfTypeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PreferredAlignOfTypeOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::PreferredAlignOfTypeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Type argument(void) const;
-};
-static_assert(sizeof(PreferredAlignOfTypeOp) == sizeof(Operation));
-
-class MX_EXPORT RealOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_REAL;
-  }
-
-  static std::optional<RealOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RealOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::RealOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RealOp) == sizeof(Operation));
-
-class MX_EXPORT RecordMemberOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_MEMBER;
-  }
-
-  static std::optional<RecordMemberOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RecordMemberOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::RecordMemberOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value record(void) const;
-  ::mx::ir::Value element(void) const;
-  std::string_view field(void) const;
-};
-static_assert(sizeof(RecordMemberOp) == sizeof(Operation));
-
-class MX_EXPORT RemFAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_FREM;
-  }
-
-  static std::optional<RemFAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RemFAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::RemFAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RemFAssignOp) == sizeof(Operation));
-
-class MX_EXPORT RemFOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FREM;
-  }
-
-  static std::optional<RemFOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RemFOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::RemFOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RemFOp) == sizeof(Operation));
-
-class MX_EXPORT RemSAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_SREM;
-  }
-
-  static std::optional<RemSAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RemSAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::RemSAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RemSAssignOp) == sizeof(Operation));
-
-class MX_EXPORT RemSOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_SREM;
-  }
-
-  static std::optional<RemSOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RemSOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::RemSOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RemSOp) == sizeof(Operation));
-
-class MX_EXPORT RemUAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_UREM;
-  }
-
-  static std::optional<RemUAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RemUAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::RemUAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RemUAssignOp) == sizeof(Operation));
-
-class MX_EXPORT RemUOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_UREM;
-  }
-
-  static std::optional<RemUOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RemUOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::RemUOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RemUOp) == sizeof(Operation));
-
-class MX_EXPORT ReturnOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_RETURN;
-  }
-
-  static std::optional<ReturnOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ReturnOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ReturnOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> result(void) const &;
-};
-static_assert(sizeof(ReturnOp) == sizeof(Operation));
-
-class MX_EXPORT SizeOfExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_SIZEOF_EXPR;
-  }
-
-  static std::optional<SizeOfExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SizeOfExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::SizeOfExprOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region expression(void) const;
-  std::size_t value(void) const;
-};
-static_assert(sizeof(SizeOfExprOp) == sizeof(Operation));
-
-class MX_EXPORT SizeOfTypeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_SIZEOF_TYPE;
-  }
-
-  static std::optional<SizeOfTypeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SizeOfTypeOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::SizeOfTypeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Type argument(void) const;
-  std::size_t value(void) const;
-};
-static_assert(sizeof(SizeOfTypeOp) == sizeof(Operation));
-
-class MX_EXPORT StaticAssertDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_STATIC_ASSERT;
-  }
-
-  static std::optional<StaticAssertDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StaticAssertDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::StaticAssertDecl underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region assertion(void) const;
-  ::mx::ir::Region message(void) const;
-  bool failed(void) const;
-};
-static_assert(sizeof(StaticAssertDeclOp) == sizeof(Operation));
-
-class MX_EXPORT StmtExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_STMT_EXPR;
-  }
-
-  static std::optional<StmtExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StmtExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::StmtExprOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region nested_statement(void) const;
-};
-static_assert(sizeof(StmtExprOp) == sizeof(Operation));
-
-class MX_EXPORT StructDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_STRUCT;
-  }
-
-  static std::optional<StructDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StructDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::StructDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region fields(void) const;
-  std::string_view name(void) const;
-  gap::generator<::mx::ir::Type> field_types(void) const &;
-  //gap::generator<field_info_t> fields_info(void) const;
-  //gap::generator<AggregateTypeDefinitionInterface> nested_declarations(void) const;
-  ::mx::ir::Type defined_type(void) const;
-  bool is_complete_definition(void) const;
-  ::mx::ir::Block fields_block(void) const;
-};
-static_assert(sizeof(StructDeclOp) == sizeof(Operation));
-
-class MX_EXPORT SubFAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_FSUB;
-  }
-
-  static std::optional<SubFAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SubFAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::SubFAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SubFAssignOp) == sizeof(Operation));
-
-class MX_EXPORT SubFOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_FSUB;
-  }
-
-  static std::optional<SubFOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SubFOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::SubFOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SubFOp) == sizeof(Operation));
-
-class MX_EXPORT SubIAssignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ASSIGN_SUB;
-  }
-
-  static std::optional<SubIAssignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SubIAssignOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::SubIAssignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value destination(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SubIAssignOp) == sizeof(Operation));
-
-class MX_EXPORT SubIOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_SUB;
-  }
-
-  static std::optional<SubIOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SubIOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::SubIOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SubIOp) == sizeof(Operation));
-
-class MX_EXPORT SubscriptOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_SUBSCRIPT;
-  }
-
-  static std::optional<SubscriptOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SubscriptOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::SubscriptOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value array(void) const;
-  ::mx::ir::Value index(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SubscriptOp) == sizeof(Operation));
-
-class MX_EXPORT SwitchOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_SWITCH;
-  }
-
-  static std::optional<SwitchOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SwitchOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::SwitchOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region condition_region(void) const;
-  gap::generator<::mx::ir::Region> cases(void) const &;
-};
-static_assert(sizeof(SwitchOp) == sizeof(Operation));
-
-class MX_EXPORT ThisOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_THIS;
-  }
-
-  static std::optional<ThisOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ThisOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ThisOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ThisOp) == sizeof(Operation));
-
-class MX_EXPORT TranslationUnitOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_TRANSLATION_UNIT;
-  }
-
-  static std::optional<TranslationUnitOp> from(const ::mx::ir::Operation &that);
-  static std::optional<TranslationUnitOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::TranslationUnitOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body(void) const;
-};
-static_assert(sizeof(TranslationUnitOp) == sizeof(Operation));
-
-class MX_EXPORT TypeAliasOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_ALIAS;
-  }
-
-  static std::optional<TypeAliasOp> from(const ::mx::ir::Operation &that);
-  static std::optional<TypeAliasOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::TypeAliasOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  ::mx::ir::Type type(void) const;
-};
-static_assert(sizeof(TypeAliasOp) == sizeof(Operation));
-
-class MX_EXPORT TypeDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_TYPE;
-  }
-
-  static std::optional<TypeDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<TypeDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::TypeDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  ::mx::ir::Type type(void) const;
-  ::mx::ir::Type defined_type(void) const;
-};
-static_assert(sizeof(TypeDeclOp) == sizeof(Operation));
-
-class MX_EXPORT TypeDefOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_TYPEDEF;
-  }
-
-  static std::optional<TypeDefOp> from(const ::mx::ir::Operation &that);
-  static std::optional<TypeDefOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::TypeDefOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  ::mx::ir::Type type(void) const;
-  ::mx::ir::Type defined_type(void) const;
-};
-static_assert(sizeof(TypeDefOp) == sizeof(Operation));
-
-class MX_EXPORT TypeOfExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_TYPEOF_EXPR;
-  }
-
-  static std::optional<TypeOfExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<TypeOfExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::TypeOfExprOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region expression(void) const;
-  std::string_view name(void) const;
-  ::mx::ir::Type type(void) const;
-};
-static_assert(sizeof(TypeOfExprOp) == sizeof(Operation));
-
-class MX_EXPORT TypeYieldOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_TYPE_YIELD;
-  }
-
-  static std::optional<TypeYieldOp> from(const ::mx::ir::Operation &that);
-  static std::optional<TypeYieldOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::TypeYieldOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Type yielded(void) const;
-};
-static_assert(sizeof(TypeYieldOp) == sizeof(Operation));
-
-class MX_EXPORT UnionDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_UNION;
-  }
-
-  static std::optional<UnionDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UnionDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::UnionDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region fields(void) const;
-  std::string_view name(void) const;
-  gap::generator<::mx::ir::Type> field_types(void) const &;
-  //gap::generator<field_info_t> fields_info(void) const;
-  //gap::generator<AggregateTypeDefinitionInterface> nested_declarations(void) const;
-  ::mx::ir::Type defined_type(void) const;
-  bool is_complete_definition(void) const;
-  ::mx::ir::Block fields_block(void) const;
-};
-static_assert(sizeof(UnionDeclOp) == sizeof(Operation));
-
-class MX_EXPORT UnreachableOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_UNREACHABLE;
-  }
-
-  static std::optional<UnreachableOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UnreachableOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::UnreachableOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(UnreachableOp) == sizeof(Operation));
-
-class MX_EXPORT VAArgExprOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_VA_ARG_EXPR;
-  }
-
-  static std::optional<VAArgExprOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VAArgExprOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::VAArgExpr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument_list(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VAArgExprOp) == sizeof(Operation));
-
-class MX_EXPORT ValueYieldOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_VALUE_YIELD;
-  }
-
-  static std::optional<ValueYieldOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ValueYieldOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::ValueYieldOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ValueYieldOp) == sizeof(Operation));
-
-class MX_EXPORT VarDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_VAR;
-  }
-
-  static std::optional<VarDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VarDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::VarDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  std::optional<::mx::ir::Region> initializer(void) const;
-  std::optional<::mx::ir::Region> allocation_size(void) const;
-  std::string_view name(void) const;
-  //::std::optional<StorageClass> storage_class(void) const;
-  //::std::optional<TSClass> thread_storage_class(void) const;
-  bool has_local_storage(void) const;
-  bool is_local_variable_declaration(void) const;
-  bool is_static_local_variable_declaration(void) const;
-  bool has_external_storage(void) const;
-  bool has_global_storage(void) const;
-  //StorageDuration storage_duration(void) const;
-  //DeclContextKind decl_context_kind(void) const;
-  bool is_static_data_member(void) const;
-  bool is_in_file_context(void) const;
-  bool is_in_function_or_method_context(void) const;
-  bool is_in_record_context(void) const;
-  bool is_file_variable_declaration(void) const;
-};
-static_assert(sizeof(VarDeclOp) == sizeof(Operation));
-
-class MX_EXPORT WhileOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::HL_WHILE;
-  }
-
-  static std::optional<WhileOp> from(const ::mx::ir::Operation &that);
-  static std::optional<WhileOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::hl::WhileOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region condition_region(void) const;
-  ::mx::ir::Region body_region(void) const;
-};
-static_assert(sizeof(WhileOp) == sizeof(Operation));
-
-}  // namespace mx::ir::hl
diff --git a/include/multiplier/IR/HighLevel/Type.h b/include/multiplier/IR/HighLevel/Type.h
deleted file mode 100644
index a630ef14b..000000000
--- a/include/multiplier/IR/HighLevel/Type.h
+++ /dev/null
@@ -1,550 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Type.h"
-
-namespace vast::hl {
-class RecordType;
-class EnumType;
-class TypedefType;
-class ElaboratedType;
-class LabelType;
-class ParenType;
-class LValueType;
-class RValueType;
-class VoidType;
-class BoolType;
-class CharType;
-class ShortType;
-class IntType;
-class LongType;
-class LongLongType;
-class Int128Type;
-class HalfType;
-class BFloat16Type;
-class FloatType;
-class DoubleType;
-class LongDoubleType;
-class Float128Type;
-class ComplexType;
-class PointerType;
-class ArrayType;
-class VectorType;
-class DecayedType;
-class AttributedType;
-class AdjustedType;
-class ReferenceType;
-class TypeOfExprType;
-class TypeOfTypeType;
-class AutoType;
-class AtomicType;
-}  // namespace vast::hl
-namespace mx::ir::hl {
-
-class MX_EXPORT Type : public ::mx::ir::Type {
- public:
-  static std::optional<Type> from(const ::mx::ir::Type &);
-};
-static_assert(sizeof(Type) == sizeof(::mx::ir::Type));
-
-class MX_EXPORT RecordType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_RECORD;
-  }
-
-  static std::optional<RecordType> from(const ::mx::ir::Type &that);
-  ::vast::hl::RecordType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(RecordType) == sizeof(Type));
-
-class MX_EXPORT EnumType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_ENUM;
-  }
-
-  static std::optional<EnumType> from(const ::mx::ir::Type &that);
-  ::vast::hl::EnumType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(EnumType) == sizeof(Type));
-
-class MX_EXPORT TypedefType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_TYPEDEF;
-  }
-
-  static std::optional<TypedefType> from(const ::mx::ir::Type &that);
-  ::vast::hl::TypedefType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(TypedefType) == sizeof(Type));
-
-class MX_EXPORT ElaboratedType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_ELABORATED;
-  }
-
-  static std::optional<ElaboratedType> from(const ::mx::ir::Type &that);
-  ::vast::hl::ElaboratedType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(ElaboratedType) == sizeof(Type));
-
-class MX_EXPORT LabelType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_LABEL;
-  }
-
-  static std::optional<LabelType> from(const ::mx::ir::Type &that);
-  ::vast::hl::LabelType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(LabelType) == sizeof(Type));
-
-class MX_EXPORT ParenType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_PAREN;
-  }
-
-  static std::optional<ParenType> from(const ::mx::ir::Type &that);
-  ::vast::hl::ParenType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-};
-static_assert(sizeof(ParenType) == sizeof(Type));
-
-class MX_EXPORT LValueType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_L_VALUE;
-  }
-
-  static std::optional<LValueType> from(const ::mx::ir::Type &that);
-  ::vast::hl::LValueType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-};
-static_assert(sizeof(LValueType) == sizeof(Type));
-
-class MX_EXPORT RValueType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_R_VALUE;
-  }
-
-  static std::optional<RValueType> from(const ::mx::ir::Type &that);
-  ::vast::hl::RValueType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-};
-static_assert(sizeof(RValueType) == sizeof(Type));
-
-class MX_EXPORT VoidType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_VOID;
-  }
-
-  static std::optional<VoidType> from(const ::mx::ir::Type &that);
-  ::vast::hl::VoidType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(VoidType) == sizeof(Type));
-
-class MX_EXPORT BoolType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_BOOL;
-  }
-
-  static std::optional<BoolType> from(const ::mx::ir::Type &that);
-  ::vast::hl::BoolType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(BoolType) == sizeof(Type));
-
-class MX_EXPORT CharType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_CHAR;
-  }
-
-  static std::optional<CharType> from(const ::mx::ir::Type &that);
-  ::vast::hl::CharType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //UCVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(CharType) == sizeof(Type));
-
-class MX_EXPORT ShortType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_SHORT;
-  }
-
-  static std::optional<ShortType> from(const ::mx::ir::Type &that);
-  ::vast::hl::ShortType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //UCVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(ShortType) == sizeof(Type));
-
-class MX_EXPORT IntType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_INT;
-  }
-
-  static std::optional<IntType> from(const ::mx::ir::Type &that);
-  ::vast::hl::IntType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //UCVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(IntType) == sizeof(Type));
-
-class MX_EXPORT LongType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_LONG;
-  }
-
-  static std::optional<LongType> from(const ::mx::ir::Type &that);
-  ::vast::hl::LongType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //UCVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(LongType) == sizeof(Type));
-
-class MX_EXPORT LongLongType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_LONG_LONG;
-  }
-
-  static std::optional<LongLongType> from(const ::mx::ir::Type &that);
-  ::vast::hl::LongLongType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //UCVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(LongLongType) == sizeof(Type));
-
-class MX_EXPORT Int128Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_INT128;
-  }
-
-  static std::optional<Int128Type> from(const ::mx::ir::Type &that);
-  ::vast::hl::Int128Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //UCVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(Int128Type) == sizeof(Type));
-
-class MX_EXPORT HalfType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_HALF;
-  }
-
-  static std::optional<HalfType> from(const ::mx::ir::Type &that);
-  ::vast::hl::HalfType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(HalfType) == sizeof(Type));
-
-class MX_EXPORT BFloat16Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_B_FLOAT16;
-  }
-
-  static std::optional<BFloat16Type> from(const ::mx::ir::Type &that);
-  ::vast::hl::BFloat16Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(BFloat16Type) == sizeof(Type));
-
-class MX_EXPORT FloatType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_FLOAT;
-  }
-
-  static std::optional<FloatType> from(const ::mx::ir::Type &that);
-  ::vast::hl::FloatType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(FloatType) == sizeof(Type));
-
-class MX_EXPORT DoubleType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_DOUBLE;
-  }
-
-  static std::optional<DoubleType> from(const ::mx::ir::Type &that);
-  ::vast::hl::DoubleType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(DoubleType) == sizeof(Type));
-
-class MX_EXPORT LongDoubleType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_LONG_DOUBLE;
-  }
-
-  static std::optional<LongDoubleType> from(const ::mx::ir::Type &that);
-  ::vast::hl::LongDoubleType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(LongDoubleType) == sizeof(Type));
-
-class MX_EXPORT Float128Type final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_FLOAT128;
-  }
-
-  static std::optional<Float128Type> from(const ::mx::ir::Type &that);
-  ::vast::hl::Float128Type underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //CVQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(Float128Type) == sizeof(Type));
-
-class MX_EXPORT ComplexType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_COMPLEX;
-  }
-
-  static std::optional<ComplexType> from(const ::mx::ir::Type &that);
-  ::vast::hl::ComplexType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(ComplexType) == sizeof(Type));
-
-class MX_EXPORT PointerType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_POINTER;
-  }
-
-  static std::optional<PointerType> from(const ::mx::ir::Type &that);
-  ::vast::hl::PointerType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(PointerType) == sizeof(Type));
-
-class MX_EXPORT ArrayType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_ARRAY;
-  }
-
-  static std::optional<ArrayType> from(const ::mx::ir::Type &that);
-  ::vast::hl::ArrayType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //std::tuple<vector<optional<unsigned long long>, allocator<optional<unsigned long long>>>, Type> dim__and__type(void) const;
-  //dimensions_t dimensions(void) const;
-  //SizeParam size(void) const;
-  //Type element_type(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(ArrayType) == sizeof(Type));
-
-class MX_EXPORT VectorType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_VECTOR;
-  }
-
-  static std::optional<VectorType> from(const ::mx::ir::Type &that);
-  ::vast::hl::VectorType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //std::tuple<vector<optional<unsigned long long>, allocator<optional<unsigned long long>>>, Type> dim__and__type(void) const;
-  //dimensions_t dimensions(void) const;
-  //SizeParam size(void) const;
-  //Type element_type(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(VectorType) == sizeof(Type));
-
-class MX_EXPORT DecayedType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_DECAYED;
-  }
-
-  static std::optional<DecayedType> from(const ::mx::ir::Type &that);
-  ::vast::hl::DecayedType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-};
-static_assert(sizeof(DecayedType) == sizeof(Type));
-
-class MX_EXPORT AttributedType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_ATTRIBUTED;
-  }
-
-  static std::optional<AttributedType> from(const ::mx::ir::Type &that);
-  ::vast::hl::AttributedType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-};
-static_assert(sizeof(AttributedType) == sizeof(Type));
-
-class MX_EXPORT AdjustedType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_ADJUSTED;
-  }
-
-  static std::optional<AdjustedType> from(const ::mx::ir::Type &that);
-  ::vast::hl::AdjustedType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type original(void) const;
-  //Type adjusted(void) const;
-};
-static_assert(sizeof(AdjustedType) == sizeof(Type));
-
-class MX_EXPORT ReferenceType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_REFERENCE;
-  }
-
-  static std::optional<ReferenceType> from(const ::mx::ir::Type &that);
-  ::vast::hl::ReferenceType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-};
-static_assert(sizeof(ReferenceType) == sizeof(Type));
-
-class MX_EXPORT TypeOfExprType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_TYPE_OF_EXPR;
-  }
-
-  static std::optional<TypeOfExprType> from(const ::mx::ir::Type &that);
-  ::vast::hl::TypeOfExprType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(TypeOfExprType) == sizeof(Type));
-
-class MX_EXPORT TypeOfTypeType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_TYPE_OF_TYPE;
-  }
-
-  static std::optional<TypeOfTypeType> from(const ::mx::ir::Type &that);
-  ::vast::hl::TypeOfTypeType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type unmodified_type(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(TypeOfTypeType) == sizeof(Type));
-
-class MX_EXPORT AutoType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_AUTO;
-  }
-
-  static std::optional<AutoType> from(const ::mx::ir::Type &that);
-  ::vast::hl::AutoType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type deduced_type(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(AutoType) == sizeof(Type));
-
-class MX_EXPORT AtomicType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::HL_ATOMIC;
-  }
-
-  static std::optional<AtomicType> from(const ::mx::ir::Type &that);
-  ::vast::hl::AtomicType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-  //CVRQualifiersAttr quals(void) const;
-};
-static_assert(sizeof(AtomicType) == sizeof(Type));
-
-}  // namespace mx::ir::hl
diff --git a/include/multiplier/IR/LLVM/Attribute.h b/include/multiplier/IR/LLVM/Attribute.h
deleted file mode 100644
index 5e093ddcc..000000000
--- a/include/multiplier/IR/LLVM/Attribute.h
+++ /dev/null
@@ -1,863 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Attribute.h"
-
-namespace mlir::LLVM {
-class CConvAttr;
-class ComdatAttr;
-class LinkageAttr;
-class FramePointerKindAttr;
-class LoopVectorizeAttr;
-class LoopInterleaveAttr;
-class LoopUnrollAttr;
-class LoopUnrollAndJamAttr;
-class LoopLICMAttr;
-class LoopDistributeAttr;
-class LoopPipelineAttr;
-class LoopPeeledAttr;
-class LoopUnswitchAttr;
-class LoopAnnotationAttr;
-class DIExpressionElemAttr;
-class DIExpressionAttr;
-class DINullTypeAttr;
-class DIBasicTypeAttr;
-class DICompileUnitAttr;
-class DICompositeTypeAttr;
-class DIDerivedTypeAttr;
-class DIFileAttr;
-class DIGlobalVariableExpressionAttr;
-class DIGlobalVariableAttr;
-class DILexicalBlockAttr;
-class DILexicalBlockFileAttr;
-class DILocalVariableAttr;
-class DISubprogramAttr;
-class DIModuleAttr;
-class DINamespaceAttr;
-class DISubrangeAttr;
-class DISubroutineTypeAttr;
-class DILabelAttr;
-class MemoryEffectsAttr;
-class AliasScopeDomainAttr;
-class AliasScopeAttr;
-class AccessGroupAttr;
-class TBAARootAttr;
-class TBAAMemberAttr;
-class TBAATypeDescriptorAttr;
-class TBAATagAttr;
-class VScaleRangeAttr;
-class TargetFeaturesAttr;
-class IntegerOverflowFlagsAttr;
-class FastmathFlagsAttr;
-}  // namespace mlir::LLVM
-namespace mx::ir::llvm {
-
-class MX_EXPORT Attribute : public ::mx::ir::Attribute {
- public:
-  static std::optional<Attribute> from(const ::mx::ir::Attribute &);
-};
-static_assert(sizeof(Attribute) == sizeof(::mx::ir::Attribute));
-
-class MX_EXPORT CConvAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_C_CONV;
-  }
-
-  static std::optional<CConvAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::CConvAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //CConv calling_conv(void) const;
-};
-static_assert(sizeof(CConvAttr) == sizeof(Attribute));
-
-class MX_EXPORT ComdatAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_COMDAT;
-  }
-
-  static std::optional<ComdatAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::ComdatAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //comdat::Comdat comdat(void) const;
-};
-static_assert(sizeof(ComdatAttr) == sizeof(Attribute));
-
-class MX_EXPORT LinkageAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LINKAGE;
-  }
-
-  static std::optional<LinkageAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LinkageAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //linkage::Linkage linkage(void) const;
-};
-static_assert(sizeof(LinkageAttr) == sizeof(Attribute));
-
-class MX_EXPORT FramePointerKindAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_FRAME_POINTER_KIND;
-  }
-
-  static std::optional<FramePointerKindAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::FramePointerKindAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //framePointerKind::FramePointerKind frame_pointer_kind(void) const;
-};
-static_assert(sizeof(FramePointerKindAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopVectorizeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_VECTORIZE;
-  }
-
-  static std::optional<LoopVectorizeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopVectorizeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //BoolAttr disable(void) const;
-  //BoolAttr predicate_enable(void) const;
-  //BoolAttr scalable_enable(void) const;
-  //IntegerAttr width(void) const;
-  //LoopAnnotationAttr followup_vectorized(void) const;
-  //LoopAnnotationAttr followup_epilogue(void) const;
-  //LoopAnnotationAttr followup_all(void) const;
-};
-static_assert(sizeof(LoopVectorizeAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopInterleaveAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_INTERLEAVE;
-  }
-
-  static std::optional<LoopInterleaveAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopInterleaveAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //IntegerAttr count(void) const;
-};
-static_assert(sizeof(LoopInterleaveAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopUnrollAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_UNROLL;
-  }
-
-  static std::optional<LoopUnrollAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopUnrollAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //BoolAttr disable(void) const;
-  //IntegerAttr count(void) const;
-  //BoolAttr runtime_disable(void) const;
-  //BoolAttr full(void) const;
-  //LoopAnnotationAttr followup_unrolled(void) const;
-  //LoopAnnotationAttr followup_remainder(void) const;
-  //LoopAnnotationAttr followup_all(void) const;
-};
-static_assert(sizeof(LoopUnrollAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopUnrollAndJamAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_UNROLL_AND_JAM;
-  }
-
-  static std::optional<LoopUnrollAndJamAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopUnrollAndJamAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //BoolAttr disable(void) const;
-  //IntegerAttr count(void) const;
-  //LoopAnnotationAttr followup_outer(void) const;
-  //LoopAnnotationAttr followup_inner(void) const;
-  //LoopAnnotationAttr followup_remainder_outer(void) const;
-  //LoopAnnotationAttr followup_remainder_inner(void) const;
-  //LoopAnnotationAttr followup_all(void) const;
-};
-static_assert(sizeof(LoopUnrollAndJamAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopLICMAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_LICM;
-  }
-
-  static std::optional<LoopLICMAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopLICMAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //BoolAttr disable(void) const;
-  //BoolAttr versioning_disable(void) const;
-};
-static_assert(sizeof(LoopLICMAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopDistributeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_DISTRIBUTE;
-  }
-
-  static std::optional<LoopDistributeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopDistributeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //BoolAttr disable(void) const;
-  //LoopAnnotationAttr followup_coincident(void) const;
-  //LoopAnnotationAttr followup_sequential(void) const;
-  //LoopAnnotationAttr followup_fallback(void) const;
-  //LoopAnnotationAttr followup_all(void) const;
-};
-static_assert(sizeof(LoopDistributeAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopPipelineAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_PIPELINE;
-  }
-
-  static std::optional<LoopPipelineAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopPipelineAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //BoolAttr disable(void) const;
-  //IntegerAttr initiationinterval(void) const;
-};
-static_assert(sizeof(LoopPipelineAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopPeeledAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_PEELED;
-  }
-
-  static std::optional<LoopPeeledAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopPeeledAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //IntegerAttr count(void) const;
-};
-static_assert(sizeof(LoopPeeledAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopUnswitchAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_UNSWITCH;
-  }
-
-  static std::optional<LoopUnswitchAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopUnswitchAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //BoolAttr partial_disable(void) const;
-};
-static_assert(sizeof(LoopUnswitchAttr) == sizeof(Attribute));
-
-class MX_EXPORT LoopAnnotationAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_LOOP_ANNOTATION;
-  }
-
-  static std::optional<LoopAnnotationAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::LoopAnnotationAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //BoolAttr disable_nonforced(void) const;
-  //LoopVectorizeAttr vectorize(void) const;
-  //LoopInterleaveAttr interleave(void) const;
-  //LoopUnrollAttr unroll(void) const;
-  //LoopUnrollAndJamAttr unroll_and_jam(void) const;
-  //LoopLICMAttr licm(void) const;
-  //LoopDistributeAttr distribute(void) const;
-  //LoopPipelineAttr pipeline(void) const;
-  //LoopPeeledAttr peeled(void) const;
-  //LoopUnswitchAttr unswitch(void) const;
-  //BoolAttr must_progress(void) const;
-  //BoolAttr is_vectorized(void) const;
-  //FusedLoc start_loc(void) const;
-  //FusedLoc end_loc(void) const;
-  //::llvm::ArrayRef<AccessGroupAttr> parallel_accesses(void) const;
-};
-static_assert(sizeof(LoopAnnotationAttr) == sizeof(Attribute));
-
-class MX_EXPORT DIExpressionElemAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_EXPRESSION_ELEM;
-  }
-
-  static std::optional<DIExpressionElemAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DIExpressionElemAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int opcode(void) const;
-  //::llvm::ArrayRef<unsigned long long> arguments(void) const;
-};
-static_assert(sizeof(DIExpressionElemAttr) == sizeof(Attribute));
-
-class MX_EXPORT DIExpressionAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_EXPRESSION;
-  }
-
-  static std::optional<DIExpressionAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DIExpressionAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::llvm::ArrayRef<DIExpressionElemAttr> operations(void) const;
-};
-static_assert(sizeof(DIExpressionAttr) == sizeof(Attribute));
-
-class MX_EXPORT DINullTypeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_NULL_TYPE;
-  }
-
-  static std::optional<DINullTypeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DINullTypeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(DINullTypeAttr) == sizeof(Attribute));
-
-class MX_EXPORT DIBasicTypeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_BASIC_TYPE;
-  }
-
-  static std::optional<DIBasicTypeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DIBasicTypeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int tag(void) const;
-  //StringAttr name(void) const;
-  uint64_t size_in_bits(void) const;
-  unsigned int encoding(void) const;
-};
-static_assert(sizeof(DIBasicTypeAttr) == sizeof(Attribute));
-
-class MX_EXPORT DICompileUnitAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_COMPILE_UNIT;
-  }
-
-  static std::optional<DICompileUnitAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DICompileUnitAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DistinctAttr id(void) const;
-  unsigned int source_language(void) const;
-  //DIFileAttr file(void) const;
-  //StringAttr producer(void) const;
-  bool is_optimized(void) const;
-  //DIEmissionKind emission_kind(void) const;
-};
-static_assert(sizeof(DICompileUnitAttr) == sizeof(Attribute));
-
-class MX_EXPORT DICompositeTypeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_COMPOSITE_TYPE;
-  }
-
-  static std::optional<DICompositeTypeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DICompositeTypeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int tag(void) const;
-  //StringAttr name(void) const;
-  //DIFileAttr file(void) const;
-  uint32_t line(void) const;
-  //DIScopeAttr scope(void) const;
-  //DITypeAttr base_type(void) const;
-  //DIFlags flags(void) const;
-  uint64_t size_in_bits(void) const;
-  uint64_t align_in_bits(void) const;
-  //::llvm::ArrayRef<DINodeAttr> elements(void) const;
-};
-static_assert(sizeof(DICompositeTypeAttr) == sizeof(Attribute));
-
-class MX_EXPORT DIDerivedTypeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_DERIVED_TYPE;
-  }
-
-  static std::optional<DIDerivedTypeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DIDerivedTypeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int tag(void) const;
-  //StringAttr name(void) const;
-  //DITypeAttr base_type(void) const;
-  uint64_t size_in_bits(void) const;
-  uint32_t align_in_bits(void) const;
-  uint64_t offset_in_bits(void) const;
-};
-static_assert(sizeof(DIDerivedTypeAttr) == sizeof(Attribute));
-
-class MX_EXPORT DIFileAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_FILE;
-  }
-
-  static std::optional<DIFileAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DIFileAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //StringAttr name(void) const;
-  //StringAttr directory(void) const;
-};
-static_assert(sizeof(DIFileAttr) == sizeof(Attribute));
-
-class MX_EXPORT DIGlobalVariableExpressionAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_GLOBAL_VARIABLE_EXPRESSION;
-  }
-
-  static std::optional<DIGlobalVariableExpressionAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DIGlobalVariableExpressionAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DIGlobalVariableAttr var(void) const;
-  //DIExpressionAttr expression(void) const;
-};
-static_assert(sizeof(DIGlobalVariableExpressionAttr) == sizeof(Attribute));
-
-class MX_EXPORT DIGlobalVariableAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_GLOBAL_VARIABLE;
-  }
-
-  static std::optional<DIGlobalVariableAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DIGlobalVariableAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DIScopeAttr scope(void) const;
-  //StringAttr name(void) const;
-  //StringAttr linkage_name(void) const;
-  //DIFileAttr file(void) const;
-  unsigned int line(void) const;
-  //DITypeAttr type(void) const;
-  bool is_local_to_unit(void) const;
-  bool is_defined(void) const;
-  unsigned int align_in_bits(void) const;
-};
-static_assert(sizeof(DIGlobalVariableAttr) == sizeof(Attribute));
-
-class MX_EXPORT DILexicalBlockAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_LEXICAL_BLOCK;
-  }
-
-  static std::optional<DILexicalBlockAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DILexicalBlockAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DIScopeAttr scope(void) const;
-  //DIFileAttr file(void) const;
-  unsigned int line(void) const;
-  unsigned int column(void) const;
-};
-static_assert(sizeof(DILexicalBlockAttr) == sizeof(Attribute));
-
-class MX_EXPORT DILexicalBlockFileAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_LEXICAL_BLOCK_FILE;
-  }
-
-  static std::optional<DILexicalBlockFileAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DILexicalBlockFileAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DIScopeAttr scope(void) const;
-  //DIFileAttr file(void) const;
-  unsigned int discriminator(void) const;
-};
-static_assert(sizeof(DILexicalBlockFileAttr) == sizeof(Attribute));
-
-class MX_EXPORT DILocalVariableAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_LOCAL_VARIABLE;
-  }
-
-  static std::optional<DILocalVariableAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DILocalVariableAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DIScopeAttr scope(void) const;
-  //StringAttr name(void) const;
-  //DIFileAttr file(void) const;
-  unsigned int line(void) const;
-  unsigned int argument(void) const;
-  unsigned int align_in_bits(void) const;
-  //DITypeAttr type(void) const;
-};
-static_assert(sizeof(DILocalVariableAttr) == sizeof(Attribute));
-
-class MX_EXPORT DISubprogramAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_SUBPROGRAM;
-  }
-
-  static std::optional<DISubprogramAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DISubprogramAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DistinctAttr id(void) const;
-  //DICompileUnitAttr compile_unit(void) const;
-  //DIScopeAttr scope(void) const;
-  //StringAttr name(void) const;
-  //StringAttr linkage_name(void) const;
-  //DIFileAttr file(void) const;
-  unsigned int line(void) const;
-  unsigned int scope_line(void) const;
-  //DISubprogramFlags subprogram_flags(void) const;
-  //DISubroutineTypeAttr type(void) const;
-};
-static_assert(sizeof(DISubprogramAttr) == sizeof(Attribute));
-
-class MX_EXPORT DIModuleAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_MODULE;
-  }
-
-  static std::optional<DIModuleAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DIModuleAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DIFileAttr file(void) const;
-  //DIScopeAttr scope(void) const;
-  //StringAttr name(void) const;
-  //StringAttr config_macros(void) const;
-  //StringAttr include_path(void) const;
-  //StringAttr apinotes(void) const;
-  unsigned int line(void) const;
-  bool is_decl(void) const;
-};
-static_assert(sizeof(DIModuleAttr) == sizeof(Attribute));
-
-class MX_EXPORT DINamespaceAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_NAMESPACE;
-  }
-
-  static std::optional<DINamespaceAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DINamespaceAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //StringAttr name(void) const;
-  //DIScopeAttr scope(void) const;
-  bool export_symbols(void) const;
-};
-static_assert(sizeof(DINamespaceAttr) == sizeof(Attribute));
-
-class MX_EXPORT DISubrangeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_SUBRANGE;
-  }
-
-  static std::optional<DISubrangeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DISubrangeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //IntegerAttr count(void) const;
-  //IntegerAttr lower_bound(void) const;
-  //IntegerAttr upper_bound(void) const;
-  //IntegerAttr stride(void) const;
-};
-static_assert(sizeof(DISubrangeAttr) == sizeof(Attribute));
-
-class MX_EXPORT DISubroutineTypeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_SUBROUTINE_TYPE;
-  }
-
-  static std::optional<DISubroutineTypeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DISubroutineTypeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int calling_convention(void) const;
-  //::llvm::ArrayRef<DITypeAttr> types(void) const;
-};
-static_assert(sizeof(DISubroutineTypeAttr) == sizeof(Attribute));
-
-class MX_EXPORT DILabelAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_DI_LABEL;
-  }
-
-  static std::optional<DILabelAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::DILabelAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DIScopeAttr scope(void) const;
-  //StringAttr name(void) const;
-  //DIFileAttr file(void) const;
-  unsigned int line(void) const;
-};
-static_assert(sizeof(DILabelAttr) == sizeof(Attribute));
-
-class MX_EXPORT MemoryEffectsAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_MEMORY_EFFECTS;
-  }
-
-  static std::optional<MemoryEffectsAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::MemoryEffectsAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool is_read_write(void) const;
-  //ModRefInfo other(void) const;
-  //ModRefInfo arg_mem(void) const;
-  //ModRefInfo inaccessible_mem(void) const;
-};
-static_assert(sizeof(MemoryEffectsAttr) == sizeof(Attribute));
-
-class MX_EXPORT AliasScopeDomainAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_ALIAS_SCOPE_DOMAIN;
-  }
-
-  static std::optional<AliasScopeDomainAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::AliasScopeDomainAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DistinctAttr id(void) const;
-  //StringAttr description(void) const;
-};
-static_assert(sizeof(AliasScopeDomainAttr) == sizeof(Attribute));
-
-class MX_EXPORT AliasScopeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_ALIAS_SCOPE;
-  }
-
-  static std::optional<AliasScopeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::AliasScopeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DistinctAttr id(void) const;
-  //AliasScopeDomainAttr domain(void) const;
-  //StringAttr description(void) const;
-};
-static_assert(sizeof(AliasScopeAttr) == sizeof(Attribute));
-
-class MX_EXPORT AccessGroupAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_ACCESS_GROUP;
-  }
-
-  static std::optional<AccessGroupAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::AccessGroupAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //DistinctAttr id(void) const;
-};
-static_assert(sizeof(AccessGroupAttr) == sizeof(Attribute));
-
-class MX_EXPORT TBAARootAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_TBAA_ROOT;
-  }
-
-  static std::optional<TBAARootAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::TBAARootAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //StringAttr id(void) const;
-};
-static_assert(sizeof(TBAARootAttr) == sizeof(Attribute));
-
-class MX_EXPORT TBAAMemberAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_TBAA_MEMBER;
-  }
-
-  static std::optional<TBAAMemberAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::TBAAMemberAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //TBAANodeAttr type_desc(void) const;
-  int64_t offset(void) const;
-};
-static_assert(sizeof(TBAAMemberAttr) == sizeof(Attribute));
-
-class MX_EXPORT TBAATypeDescriptorAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_TBAA_TYPE_DESCRIPTOR;
-  }
-
-  static std::optional<TBAATypeDescriptorAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::TBAATypeDescriptorAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view id(void) const;
-  //::llvm::ArrayRef<TBAAMemberAttr> members(void) const;
-};
-static_assert(sizeof(TBAATypeDescriptorAttr) == sizeof(Attribute));
-
-class MX_EXPORT TBAATagAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_TBAA_TAG;
-  }
-
-  static std::optional<TBAATagAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::TBAATagAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //TBAATypeDescriptorAttr base_type(void) const;
-  //TBAATypeDescriptorAttr access_type(void) const;
-  int64_t offset(void) const;
-  bool constant(void) const;
-};
-static_assert(sizeof(TBAATagAttr) == sizeof(Attribute));
-
-class MX_EXPORT VScaleRangeAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_V_SCALE_RANGE;
-  }
-
-  static std::optional<VScaleRangeAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::VScaleRangeAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //IntegerAttr min_range(void) const;
-  //IntegerAttr max_range(void) const;
-};
-static_assert(sizeof(VScaleRangeAttr) == sizeof(Attribute));
-
-class MX_EXPORT TargetFeaturesAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_TARGET_FEATURES;
-  }
-
-  static std::optional<TargetFeaturesAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::TargetFeaturesAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool null_or_empty(void) const;
-  std::string features_string(void) const;
-  //StringLiteral attribute_name(void) const;
-  //::llvm::ArrayRef<StringAttr> features(void) const;
-};
-static_assert(sizeof(TargetFeaturesAttr) == sizeof(Attribute));
-
-class MX_EXPORT IntegerOverflowFlagsAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_INTEGER_OVERFLOW_FLAGS;
-  }
-
-  static std::optional<IntegerOverflowFlagsAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::IntegerOverflowFlagsAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::LLVM::IntegerOverflowFlags value(void) const;
-};
-static_assert(sizeof(IntegerOverflowFlagsAttr) == sizeof(Attribute));
-
-class MX_EXPORT FastmathFlagsAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::LLVM_FASTMATH_FLAGS;
-  }
-
-  static std::optional<FastmathFlagsAttr> from(const ::mx::ir::Attribute &that);
-
-  ::mlir::LLVM::FastmathFlagsAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::LLVM::FastmathFlags value(void) const;
-};
-static_assert(sizeof(FastmathFlagsAttr) == sizeof(Attribute));
-
-}  // namespace mx::ir::llvm
diff --git a/include/multiplier/IR/LLVM/Dialect.h b/include/multiplier/IR/LLVM/Dialect.h
deleted file mode 100644
index cdb370293..000000000
--- a/include/multiplier/IR/LLVM/Dialect.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "Attribute.h"
-#include "Type.h"
-#include "Operation.h"
diff --git a/include/multiplier/IR/LLVM/Operation.h b/include/multiplier/IR/LLVM/Operation.h
deleted file mode 100644
index 96e4fc776..000000000
--- a/include/multiplier/IR/LLVM/Operation.h
+++ /dev/null
@@ -1,4936 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Operation.h"
-
-namespace mlir::LLVM {
-class AShrOp;
-class AddOp;
-class AddrSpaceCastOp;
-class AddressOfOp;
-class AllocaOp;
-class AndOp;
-class AtomicCmpXchgOp;
-class AtomicRMWOp;
-class BitcastOp;
-class BrOp;
-class CallIntrinsicOp;
-class CallOp;
-class ComdatOp;
-class ComdatSelectorOp;
-class CondBrOp;
-class ConstantOp;
-class ExtractElementOp;
-class ExtractValueOp;
-class FAddOp;
-class FCmpOp;
-class FDivOp;
-class FMulOp;
-class FNegOp;
-class FPExtOp;
-class FPToSIOp;
-class FPToUIOp;
-class FPTruncOp;
-class FRemOp;
-class FSubOp;
-class FenceOp;
-class FreezeOp;
-class GEPOp;
-class GlobalCtorsOp;
-class GlobalDtorsOp;
-class GlobalOp;
-class ICmpOp;
-class InlineAsmOp;
-class InsertElementOp;
-class InsertValueOp;
-class IntToPtrOp;
-class InvokeOp;
-class LLVMFuncOp;
-class LShrOp;
-class LandingpadOp;
-class LinkerOptionsOp;
-class LoadOp;
-class MulOp;
-class NoneTokenOp;
-class OrOp;
-class PoisonOp;
-class PtrToIntOp;
-class ResumeOp;
-class ReturnOp;
-class SDivOp;
-class SExtOp;
-class SIToFPOp;
-class SRemOp;
-class SelectOp;
-class ShlOp;
-class ShuffleVectorOp;
-class StoreOp;
-class SubOp;
-class SwitchOp;
-class TruncOp;
-class UDivOp;
-class UIToFPOp;
-class URemOp;
-class UndefOp;
-class UnreachableOp;
-class XOrOp;
-class ZExtOp;
-class ZeroOp;
-class AbsOp;
-class Annotation;
-class AssumeOp;
-class BitReverseOp;
-class ByteSwapOp;
-class CopySignOp;
-class CoroAlignOp;
-class CoroBeginOp;
-class CoroEndOp;
-class CoroFreeOp;
-class CoroIdOp;
-class CoroPromiseOp;
-class CoroResumeOp;
-class CoroSaveOp;
-class CoroSizeOp;
-class CoroSuspendOp;
-class CosOp;
-class CountLeadingZerosOp;
-class CountTrailingZerosOp;
-class CtPopOp;
-class DbgDeclareOp;
-class DbgLabelOp;
-class DbgValueOp;
-class DebugTrap;
-class EhTypeidForOp;
-class Exp2Op;
-class ExpOp;
-class ExpectOp;
-class ExpectWithProbabilityOp;
-class FAbsOp;
-class FCeilOp;
-class FFloorOp;
-class FMAOp;
-class FMulAddOp;
-class FTruncOp;
-class FshlOp;
-class FshrOp;
-class GetActiveLaneMaskOp;
-class InvariantEndOp;
-class InvariantStartOp;
-class IsConstantOp;
-class IsFPClass;
-class LifetimeEndOp;
-class LifetimeStartOp;
-class LlrintOp;
-class LlroundOp;
-class Log10Op;
-class Log2Op;
-class LogOp;
-class LrintOp;
-class LroundOp;
-class MaskedLoadOp;
-class MaskedStoreOp;
-class MatrixColumnMajorLoadOp;
-class MatrixColumnMajorStoreOp;
-class MatrixMultiplyOp;
-class MatrixTransposeOp;
-class MaxNumOp;
-class MaximumOp;
-class MemcpyInlineOp;
-class MemcpyOp;
-class MemmoveOp;
-class MemsetOp;
-class MinNumOp;
-class MinimumOp;
-class NearbyintOp;
-class NoAliasScopeDeclOp;
-class PowIOp;
-class PowOp;
-class Prefetch;
-class PtrAnnotation;
-class RintOp;
-class RoundEvenOp;
-class RoundOp;
-class SAddSat;
-class SAddWithOverflowOp;
-class SMaxOp;
-class SMinOp;
-class SMulWithOverflowOp;
-class SSACopyOp;
-class SSHLSat;
-class SSubSat;
-class SSubWithOverflowOp;
-class SinOp;
-class SqrtOp;
-class StackRestoreOp;
-class StackSaveOp;
-class StepVectorOp;
-class ThreadlocalAddressOp;
-class Trap;
-class UAddSat;
-class UAddWithOverflowOp;
-class UBSanTrap;
-class UMaxOp;
-class UMinOp;
-class UMulWithOverflowOp;
-class USHLSat;
-class USubSat;
-class USubWithOverflowOp;
-class VPAShrOp;
-class VPAddOp;
-class VPAndOp;
-class VPFAddOp;
-class VPFDivOp;
-class VPFMulAddOp;
-class VPFMulOp;
-class VPFNegOp;
-class VPFPExtOp;
-class VPFPToSIOp;
-class VPFPToUIOp;
-class VPFPTruncOp;
-class VPFRemOp;
-class VPFSubOp;
-class VPFmaOp;
-class VPIntToPtrOp;
-class VPLShrOp;
-class VPLoadOp;
-class VPMergeMinOp;
-class VPMulOp;
-class VPOrOp;
-class VPPtrToIntOp;
-class VPReduceAddOp;
-class VPReduceAndOp;
-class VPReduceFAddOp;
-class VPReduceFMaxOp;
-class VPReduceFMinOp;
-class VPReduceFMulOp;
-class VPReduceMulOp;
-class VPReduceOrOp;
-class VPReduceSMaxOp;
-class VPReduceSMinOp;
-class VPReduceUMaxOp;
-class VPReduceUMinOp;
-class VPReduceXorOp;
-class VPSDivOp;
-class VPSExtOp;
-class VPSIToFPOp;
-class VPSRemOp;
-class VPSelectMinOp;
-class VPShlOp;
-class VPStoreOp;
-class VPStridedLoadOp;
-class VPStridedStoreOp;
-class VPSubOp;
-class VPTruncOp;
-class VPUDivOp;
-class VPUIToFPOp;
-class VPURemOp;
-class VPXorOp;
-class VPZExtOp;
-class VaCopyOp;
-class VaEndOp;
-class VaStartOp;
-class VarAnnotation;
-class masked_compressstore;
-class masked_expandload;
-class masked_gather;
-class masked_scatter;
-class vector_extract;
-class vector_insert;
-class vector_reduce_add;
-class vector_reduce_and;
-class vector_reduce_fadd;
-class vector_reduce_fmax;
-class vector_reduce_fmaximum;
-class vector_reduce_fmin;
-class vector_reduce_fminimum;
-class vector_reduce_fmul;
-class vector_reduce_mul;
-class vector_reduce_or;
-class vector_reduce_smax;
-class vector_reduce_smin;
-class vector_reduce_umax;
-class vector_reduce_umin;
-class vector_reduce_xor;
-class vscale;
-}  // namespace mlir::LLVM
-namespace mx::ir::llvm {
-
-class MX_EXPORT Operation : public ::mx::ir::Operation {
- public:
-  static std::optional<Operation> from(const ::mx::ir::Operation &);
-};
-static_assert(sizeof(Operation) == sizeof(::mx::ir::Operation));
-
-class MX_EXPORT AShrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_ASHR;
-  }
-
-  static std::optional<AShrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AShrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AShrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AShrOp) == sizeof(Operation));
-
-class MX_EXPORT AddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_ADD;
-  }
-
-  static std::optional<AddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AddOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::IntegerOverflowFlags overflow_flags(void) const;
-};
-static_assert(sizeof(AddOp) == sizeof(Operation));
-
-class MX_EXPORT AddrSpaceCastOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_ADDRSPACECAST;
-  }
-
-  static std::optional<AddrSpaceCastOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AddrSpaceCastOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AddrSpaceCastOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AddrSpaceCastOp) == sizeof(Operation));
-
-class MX_EXPORT AddressOfOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MLIR_ADDRESSOF;
-  }
-
-  static std::optional<AddressOfOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AddressOfOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AddressOfOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> result(void) const;
-  std::string_view global_name(void) const;
-};
-static_assert(sizeof(AddressOfOp) == sizeof(Operation));
-
-class MX_EXPORT AllocaOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_ALLOCA;
-  }
-
-  static std::optional<AllocaOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AllocaOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AllocaOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> array_size(void) const;
-  //::mlir::TypedValue<LLVMPointerType> result(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  ::mx::ir::Type elem_type(void) const;
-  bool inalloca(void) const;
-  //::llvm::SmallVector<MemorySlot, 3> promotable_slots(void) const;
-  //::llvm::SmallVector<DestructurableMemorySlot, 1> destructurable_slots(void) const;
-  //Type result_ptr_element_type(void) const;
-};
-static_assert(sizeof(AllocaOp) == sizeof(Operation));
-
-class MX_EXPORT AndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_AND;
-  }
-
-  static std::optional<AndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AndOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AndOp) == sizeof(Operation));
-
-class MX_EXPORT AtomicCmpXchgOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_CMPXCHG;
-  }
-
-  static std::optional<AtomicCmpXchgOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AtomicCmpXchgOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AtomicCmpXchgOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  ::mx::ir::Value cmp(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::AtomicOrdering success_ordering(void) const;
-  //::mlir::LLVM::AtomicOrdering failure_ordering(void) const;
-  std::optional<std::string_view> syncscope(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  bool weak(void) const;
-  bool volatile__(void) const;
-  //::std::optional<ArrayAttr> access_groups(void) const;
-  //::std::optional<ArrayAttr> alias_scopes(void) const;
-  //::std::optional<ArrayAttr> noalias_scopes(void) const;
-  //::std::optional<ArrayAttr> tbaa(void) const;
-  //::llvm::SmallVector<Value, 6> accessed_operands(void) const;
-};
-static_assert(sizeof(AtomicCmpXchgOp) == sizeof(Operation));
-
-class MX_EXPORT AtomicRMWOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_ATOMICRMW;
-  }
-
-  static std::optional<AtomicRMWOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AtomicRMWOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AtomicRMWOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::AtomicBinOp bin_op(void) const;
-  //::mlir::LLVM::AtomicOrdering ordering(void) const;
-  std::optional<std::string_view> syncscope(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  bool volatile__(void) const;
-  //::std::optional<ArrayAttr> access_groups(void) const;
-  //::std::optional<ArrayAttr> alias_scopes(void) const;
-  //::std::optional<ArrayAttr> noalias_scopes(void) const;
-  //::std::optional<ArrayAttr> tbaa(void) const;
-  //::llvm::SmallVector<Value, 6> accessed_operands(void) const;
-};
-static_assert(sizeof(AtomicRMWOp) == sizeof(Operation));
-
-class MX_EXPORT BitcastOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_BITCAST;
-  }
-
-  static std::optional<BitcastOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BitcastOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::BitcastOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BitcastOp) == sizeof(Operation));
-
-class MX_EXPORT BrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_BR;
-  }
-
-  static std::optional<BrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::BrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> dest_operands(void) const &;
-  //::mlir::Block * dest(void) const;
-  //::std::optional<LoopAnnotationAttr> loop_annotation(void) const;
-};
-static_assert(sizeof(BrOp) == sizeof(Operation));
-
-class MX_EXPORT CallIntrinsicOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_CALL_INTRINSIC;
-  }
-
-  static std::optional<CallIntrinsicOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CallIntrinsicOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CallIntrinsicOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> arguments(void) const &;
-  ::mx::ir::Value results(void) const;
-  std::string_view intrin(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(CallIntrinsicOp) == sizeof(Operation));
-
-class MX_EXPORT CallOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_CALL;
-  }
-
-  static std::optional<CallOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CallOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CallOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> callee_operands(void) const &;
-  ::mx::ir::Value result(void) const;
-  //::std::optional<LLVMFunctionType> callee_type(void) const;
-  std::optional<std::string_view> callee(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-  //::std::optional<ArrayRef<int>> branch_weights(void) const;
-  //::mlir::LLVM::cconv::CConv c_conv(void) const;
-  //::std::optional<ArrayAttr> access_groups(void) const;
-  //::std::optional<ArrayAttr> alias_scopes(void) const;
-  //::std::optional<ArrayAttr> noalias_scopes(void) const;
-  //::std::optional<ArrayAttr> tbaa(void) const;
-  //::llvm::SmallVector<Value, 6> accessed_operands(void) const;
-  //::mlir::CallInterfaceCallable callable_for_callee(void) const;
-  gap::generator<::mx::ir::Operand> arg_operands(void) const &;
-  //LLVMFunctionType callee_function_type(void) const;
-};
-static_assert(sizeof(CallOp) == sizeof(Operation));
-
-class MX_EXPORT ComdatOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_COMDAT;
-  }
-
-  static std::optional<ComdatOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ComdatOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ComdatOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body(void) const;
-  std::string_view name(void) const;
-};
-static_assert(sizeof(ComdatOp) == sizeof(Operation));
-
-class MX_EXPORT ComdatSelectorOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_COMDAT_SELECTOR;
-  }
-
-  static std::optional<ComdatSelectorOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ComdatSelectorOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ComdatSelectorOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  //::mlir::LLVM::comdat::Comdat comdat(void) const;
-};
-static_assert(sizeof(ComdatSelectorOp) == sizeof(Operation));
-
-class MX_EXPORT CondBrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_COND_BR;
-  }
-
-  static std::optional<CondBrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CondBrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CondBrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> condition(void) const;
-  gap::generator<::mx::ir::Operand> true_dest_operands(void) const &;
-  gap::generator<::mx::ir::Operand> false_dest_operands(void) const &;
-  //::mlir::Block * true_dest(void) const;
-  //::mlir::Block * false_dest(void) const;
-  //::std::optional<ArrayRef<int>> branch_weights(void) const;
-  //::std::optional<LoopAnnotationAttr> loop_annotation(void) const;
-};
-static_assert(sizeof(CondBrOp) == sizeof(Operation));
-
-class MX_EXPORT ConstantOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MLIR_CONSTANT;
-  }
-
-  static std::optional<ConstantOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ConstantOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ConstantOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  //::mlir::Attribute value(void) const;
-};
-static_assert(sizeof(ConstantOp) == sizeof(Operation));
-
-class MX_EXPORT ExtractElementOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_EXTRACTELEMENT;
-  }
-
-  static std::optional<ExtractElementOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExtractElementOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ExtractElementOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value vector(void) const;
-  //::mlir::TypedValue<IntegerType> position(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ExtractElementOp) == sizeof(Operation));
-
-class MX_EXPORT ExtractValueOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_EXTRACTVALUE;
-  }
-
-  static std::optional<ExtractValueOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExtractValueOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ExtractValueOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value container(void) const;
-  ::mx::ir::Value result(void) const;
-  //::llvm::ArrayRef<long long> position(void) const;
-};
-static_assert(sizeof(ExtractValueOp) == sizeof(Operation));
-
-class MX_EXPORT FAddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FADD;
-  }
-
-  static std::optional<FAddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FAddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FAddOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FAddOp) == sizeof(Operation));
-
-class MX_EXPORT FCmpOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FCMP;
-  }
-
-  static std::optional<FCmpOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FCmpOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FCmpOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FCmpPredicate predicate(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FCmpOp) == sizeof(Operation));
-
-class MX_EXPORT FDivOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FDIV;
-  }
-
-  static std::optional<FDivOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FDivOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FDivOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FDivOp) == sizeof(Operation));
-
-class MX_EXPORT FMulOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FMUL;
-  }
-
-  static std::optional<FMulOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FMulOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FMulOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FMulOp) == sizeof(Operation));
-
-class MX_EXPORT FNegOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FNEG;
-  }
-
-  static std::optional<FNegOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FNegOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FNegOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value operand(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FNegOp) == sizeof(Operation));
-
-class MX_EXPORT FPExtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FPEXT;
-  }
-
-  static std::optional<FPExtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FPExtOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FPExtOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(FPExtOp) == sizeof(Operation));
-
-class MX_EXPORT FPToSIOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FPTOSI;
-  }
-
-  static std::optional<FPToSIOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FPToSIOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FPToSIOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(FPToSIOp) == sizeof(Operation));
-
-class MX_EXPORT FPToUIOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FPTOUI;
-  }
-
-  static std::optional<FPToUIOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FPToUIOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FPToUIOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(FPToUIOp) == sizeof(Operation));
-
-class MX_EXPORT FPTruncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FPTRUNC;
-  }
-
-  static std::optional<FPTruncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FPTruncOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FPTruncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(FPTruncOp) == sizeof(Operation));
-
-class MX_EXPORT FRemOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FREM;
-  }
-
-  static std::optional<FRemOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FRemOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FRemOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FRemOp) == sizeof(Operation));
-
-class MX_EXPORT FSubOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FSUB;
-  }
-
-  static std::optional<FSubOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FSubOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FSubOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FSubOp) == sizeof(Operation));
-
-class MX_EXPORT FenceOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FENCE;
-  }
-
-  static std::optional<FenceOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FenceOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FenceOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::LLVM::AtomicOrdering ordering(void) const;
-  std::optional<std::string_view> syncscope(void) const;
-};
-static_assert(sizeof(FenceOp) == sizeof(Operation));
-
-class MX_EXPORT FreezeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FREEZE;
-  }
-
-  static std::optional<FreezeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FreezeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FreezeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(FreezeOp) == sizeof(Operation));
-
-class MX_EXPORT GetElementPtrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_GETELEMENTPTR;
-  }
-
-  static std::optional<GetElementPtrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GetElementPtrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::GEPOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value base(void) const;
-  gap::generator<::mx::ir::Operand> dynamic_indices(void) const &;
-  ::mx::ir::Value result(void) const;
-  //::llvm::ArrayRef<int> raw_constant_indices(void) const;
-  ::mx::ir::Type elem_type(void) const;
-  bool inbounds(void) const;
-  //Type result_ptr_element_type(void) const;
-  //GEPIndicesAdaptor<ValueRange> indices(void) const;
-};
-static_assert(sizeof(GetElementPtrOp) == sizeof(Operation));
-
-class MX_EXPORT GlobalCtorsOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MLIR_GLOBAL_CTORS;
-  }
-
-  static std::optional<GlobalCtorsOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GlobalCtorsOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::GlobalCtorsOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::ArrayAttr ctors(void) const;
-  //::mlir::ArrayAttr priorities(void) const;
-};
-static_assert(sizeof(GlobalCtorsOp) == sizeof(Operation));
-
-class MX_EXPORT GlobalDtorsOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MLIR_GLOBAL_DTORS;
-  }
-
-  static std::optional<GlobalDtorsOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GlobalDtorsOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::GlobalDtorsOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::ArrayAttr dtors(void) const;
-  //::mlir::ArrayAttr priorities(void) const;
-};
-static_assert(sizeof(GlobalDtorsOp) == sizeof(Operation));
-
-class MX_EXPORT GlobalOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MLIR_GLOBAL;
-  }
-
-  static std::optional<GlobalOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GlobalOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::GlobalOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region initializer(void) const;
-  ::mx::ir::Type global_type(void) const;
-  bool constant(void) const;
-  std::string_view name(void) const;
-  //::mlir::LLVM::Linkage linkage(void) const;
-  bool dso_local(void) const;
-  bool thread_local__(void) const;
-  //::std::optional<Attribute> value(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  uint32_t addr_space(void) const;
-  //::std::optional<UnnamedAddr> unnamed_addr(void) const;
-  std::optional<std::string_view> section(void) const;
-  //::std::optional<SymbolRefAttr> comdat(void) const;
-  //::mlir::LLVM::DIGlobalVariableExpressionAttr dbg_expr(void) const;
-  //::mlir::LLVM::Visibility visibility__(void) const;
-  //Type type(void) const;
-  //Attribute value_or_null(void) const;
-  //Region & initializer_region(void) const;
-  //Block * initializer_block(void) const;
-};
-static_assert(sizeof(GlobalOp) == sizeof(Operation));
-
-class MX_EXPORT ICmpOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_ICMP;
-  }
-
-  static std::optional<ICmpOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ICmpOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ICmpOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::ICmpPredicate predicate(void) const;
-};
-static_assert(sizeof(ICmpOp) == sizeof(Operation));
-
-class MX_EXPORT InlineAsmOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INLINE_ASM;
-  }
-
-  static std::optional<InlineAsmOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InlineAsmOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::InlineAsmOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> operands(void) const &;
-  ::mx::ir::Value result(void) const;
-  std::string_view assembly(void) const;
-  std::string_view constraints(void) const;
-  bool has_side_effects(void) const;
-  bool is_align_stack(void) const;
-  //::std::optional<AsmDialect> asm_dialect(void) const;
-  //::std::optional<ArrayAttr> operand_attrs(void) const;
-};
-static_assert(sizeof(InlineAsmOp) == sizeof(Operation));
-
-class MX_EXPORT InsertElementOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INSERTELEMENT;
-  }
-
-  static std::optional<InsertElementOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InsertElementOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::InsertElementOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value vector(void) const;
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<IntegerType> position(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(InsertElementOp) == sizeof(Operation));
-
-class MX_EXPORT InsertValueOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INSERTVALUE;
-  }
-
-  static std::optional<InsertValueOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InsertValueOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::InsertValueOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value container(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-  //::llvm::ArrayRef<long long> position(void) const;
-};
-static_assert(sizeof(InsertValueOp) == sizeof(Operation));
-
-class MX_EXPORT IntToPtrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTTOPTR;
-  }
-
-  static std::optional<IntToPtrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<IntToPtrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::IntToPtrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(IntToPtrOp) == sizeof(Operation));
-
-class MX_EXPORT InvokeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INVOKE;
-  }
-
-  static std::optional<InvokeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InvokeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::InvokeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> callee_operands(void) const &;
-  gap::generator<::mx::ir::Operand> normal_dest_operands(void) const &;
-  gap::generator<::mx::ir::Operand> unwind_dest_operands(void) const &;
-  //::mlir::Block * normal_dest(void) const;
-  //::mlir::Block * unwind_dest(void) const;
-  //::std::optional<LLVMFunctionType> callee_type(void) const;
-  std::optional<std::string_view> callee(void) const;
-  //::std::optional<ArrayRef<int>> branch_weights(void) const;
-  //::mlir::LLVM::cconv::CConv c_conv(void) const;
-  //::mlir::CallInterfaceCallable callable_for_callee(void) const;
-  gap::generator<::mx::ir::Operand> arg_operands(void) const &;
-  //LLVMFunctionType callee_function_type(void) const;
-};
-static_assert(sizeof(InvokeOp) == sizeof(Operation));
-
-class MX_EXPORT FuncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_FUNC;
-  }
-
-  static std::optional<FuncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FuncOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LLVMFuncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::optional<::mx::ir::Region> body(void) const;
-  std::string_view name(void) const;
-  std::optional<std::string_view> visibility(void) const;
-  //::mlir::LLVM::LLVMFunctionType function_type(void) const;
-  //::mlir::LLVM::Linkage linkage(void) const;
-  bool dso_local(void) const;
-  //::mlir::LLVM::cconv::CConv c_conv(void) const;
-  //::std::optional<SymbolRefAttr> comdat(void) const;
-  std::optional<std::string_view> personality(void) const;
-  std::optional<std::string_view> garbage_collector(void) const;
-  //::std::optional<ArrayAttr> passthrough(void) const;
-  //::std::optional<ArrayAttr> arg_attrs(void) const;
-  //::std::optional<ArrayAttr> res_attrs(void) const;
-  std::optional<unsigned long long> function_entry_count(void) const;
-  //::std::optional<MemoryEffectsAttr> memory(void) const;
-  //::mlir::LLVM::Visibility visibility__(void) const;
-  std::optional<bool> arm_streaming(void) const;
-  std::optional<bool> arm_locally_streaming(void) const;
-  std::optional<bool> arm_streaming_compatible(void) const;
-  std::optional<bool> arm_new_za(void) const;
-  std::optional<bool> arm_preserves_za(void) const;
-  std::optional<bool> arm_shared_za(void) const;
-  std::optional<std::string_view> section(void) const;
-  //::std::optional<UnnamedAddr> unnamed_addr(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  //::std::optional<VScaleRangeAttr> vscale_range(void) const;
-  //::std::optional<FramePointerKindAttr> frame_pointer(void) const;
-  std::optional<std::string_view> target_cpu(void) const;
-  //::std::optional<TargetFeaturesAttr> target_features(void) const;
-  //Block * add_entry_block(void) const;
-  bool is_var_arg(void) const;
-  //ArrayRef<Type> argument_types(void) const;
-  //ArrayRef<Type> result_types(void) const;
-  //Region * callable_region(void) const;
-};
-static_assert(sizeof(FuncOp) == sizeof(Operation));
-
-class MX_EXPORT LShrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_LSHR;
-  }
-
-  static std::optional<LShrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LShrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LShrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(LShrOp) == sizeof(Operation));
-
-class MX_EXPORT LandingpadOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_LANDINGPAD;
-  }
-
-  static std::optional<LandingpadOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LandingpadOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LandingpadOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  bool cleanup(void) const;
-};
-static_assert(sizeof(LandingpadOp) == sizeof(Operation));
-
-class MX_EXPORT LinkerOptionsOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_LINKER_OPTIONS;
-  }
-
-  static std::optional<LinkerOptionsOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LinkerOptionsOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LinkerOptionsOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::ArrayAttr options(void) const;
-};
-static_assert(sizeof(LinkerOptionsOp) == sizeof(Operation));
-
-class MX_EXPORT LoadOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_LOAD;
-  }
-
-  static std::optional<LoadOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LoadOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LoadOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> addr(void) const;
-  ::mx::ir::Value result(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  bool volatile__(void) const;
-  bool nontemporal(void) const;
-  bool invariant(void) const;
-  //::mlir::LLVM::AtomicOrdering ordering(void) const;
-  std::optional<std::string_view> syncscope(void) const;
-  //::std::optional<ArrayAttr> access_groups(void) const;
-  //::std::optional<ArrayAttr> alias_scopes(void) const;
-  //::std::optional<ArrayAttr> noalias_scopes(void) const;
-  //::std::optional<ArrayAttr> tbaa(void) const;
-  //::llvm::SmallVector<Value, 6> accessed_operands(void) const;
-};
-static_assert(sizeof(LoadOp) == sizeof(Operation));
-
-class MX_EXPORT MulOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MUL;
-  }
-
-  static std::optional<MulOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MulOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MulOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::IntegerOverflowFlags overflow_flags(void) const;
-};
-static_assert(sizeof(MulOp) == sizeof(Operation));
-
-class MX_EXPORT NoneTokenOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MLIR_NONE;
-  }
-
-  static std::optional<NoneTokenOp> from(const ::mx::ir::Operation &that);
-  static std::optional<NoneTokenOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::NoneTokenOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(NoneTokenOp) == sizeof(Operation));
-
-class MX_EXPORT OrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_OR;
-  }
-
-  static std::optional<OrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<OrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::OrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(OrOp) == sizeof(Operation));
-
-class MX_EXPORT PoisonOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MLIR_POISON;
-  }
-
-  static std::optional<PoisonOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PoisonOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::PoisonOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(PoisonOp) == sizeof(Operation));
-
-class MX_EXPORT PtrToIntOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_PTRTOINT;
-  }
-
-  static std::optional<PtrToIntOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PtrToIntOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::PtrToIntOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(PtrToIntOp) == sizeof(Operation));
-
-class MX_EXPORT ResumeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_RESUME;
-  }
-
-  static std::optional<ResumeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ResumeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ResumeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-};
-static_assert(sizeof(ResumeOp) == sizeof(Operation));
-
-class MX_EXPORT ReturnOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_RETURN;
-  }
-
-  static std::optional<ReturnOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ReturnOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ReturnOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-};
-static_assert(sizeof(ReturnOp) == sizeof(Operation));
-
-class MX_EXPORT SDivOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_SDIV;
-  }
-
-  static std::optional<SDivOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SDivOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SDivOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SDivOp) == sizeof(Operation));
-
-class MX_EXPORT SExtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_SEXT;
-  }
-
-  static std::optional<SExtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SExtOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SExtOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SExtOp) == sizeof(Operation));
-
-class MX_EXPORT SIToFPOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_SITOFP;
-  }
-
-  static std::optional<SIToFPOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SIToFPOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SIToFPOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SIToFPOp) == sizeof(Operation));
-
-class MX_EXPORT SRemOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_SREM;
-  }
-
-  static std::optional<SRemOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SRemOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SRemOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SRemOp) == sizeof(Operation));
-
-class MX_EXPORT SelectOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_SELECT;
-  }
-
-  static std::optional<SelectOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SelectOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SelectOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value condition(void) const;
-  ::mx::ir::Value true_value(void) const;
-  ::mx::ir::Value false_value(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(SelectOp) == sizeof(Operation));
-
-class MX_EXPORT ShlOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_SHL;
-  }
-
-  static std::optional<ShlOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ShlOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ShlOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::IntegerOverflowFlags overflow_flags(void) const;
-};
-static_assert(sizeof(ShlOp) == sizeof(Operation));
-
-class MX_EXPORT ShuffleVectorOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_SHUFFLEVECTOR;
-  }
-
-  static std::optional<ShuffleVectorOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ShuffleVectorOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ShuffleVectorOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value v1(void) const;
-  ::mx::ir::Value v2(void) const;
-  ::mx::ir::Value result(void) const;
-  //::llvm::ArrayRef<int> mask(void) const;
-};
-static_assert(sizeof(ShuffleVectorOp) == sizeof(Operation));
-
-class MX_EXPORT StoreOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_STORE;
-  }
-
-  static std::optional<StoreOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StoreOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::StoreOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<LLVMPointerType> addr(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  bool volatile__(void) const;
-  bool nontemporal(void) const;
-  //::mlir::LLVM::AtomicOrdering ordering(void) const;
-  std::optional<std::string_view> syncscope(void) const;
-  //::std::optional<ArrayAttr> access_groups(void) const;
-  //::std::optional<ArrayAttr> alias_scopes(void) const;
-  //::std::optional<ArrayAttr> noalias_scopes(void) const;
-  //::std::optional<ArrayAttr> tbaa(void) const;
-  //::llvm::SmallVector<Value, 6> accessed_operands(void) const;
-};
-static_assert(sizeof(StoreOp) == sizeof(Operation));
-
-class MX_EXPORT SubOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_SUB;
-  }
-
-  static std::optional<SubOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SubOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SubOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::IntegerOverflowFlags overflow_flags(void) const;
-};
-static_assert(sizeof(SubOp) == sizeof(Operation));
-
-class MX_EXPORT SwitchOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_SWITCH;
-  }
-
-  static std::optional<SwitchOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SwitchOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SwitchOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> value(void) const;
-  gap::generator<::mx::ir::Operand> default_operands(void) const &;
-  //::mlir::OperandRangeRange case_operands(void) const;
-  //::mlir::Block * default_destination(void) const;
-  //::mlir::SuccessorRange case_destinations(void) const;
-  //::std::optional<DenseIntElementsAttr> case_values(void) const;
-  //::llvm::ArrayRef<int> case_operand_segments(void) const;
-  //::std::optional<ArrayRef<int>> branch_weights(void) const;
-};
-static_assert(sizeof(SwitchOp) == sizeof(Operation));
-
-class MX_EXPORT TruncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_TRUNC;
-  }
-
-  static std::optional<TruncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<TruncOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::TruncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(TruncOp) == sizeof(Operation));
-
-class MX_EXPORT UDivOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_UDIV;
-  }
-
-  static std::optional<UDivOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UDivOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UDivOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UDivOp) == sizeof(Operation));
-
-class MX_EXPORT UIToFPOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_UITOFP;
-  }
-
-  static std::optional<UIToFPOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UIToFPOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UIToFPOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UIToFPOp) == sizeof(Operation));
-
-class MX_EXPORT URemOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_UREM;
-  }
-
-  static std::optional<URemOp> from(const ::mx::ir::Operation &that);
-  static std::optional<URemOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::URemOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(URemOp) == sizeof(Operation));
-
-class MX_EXPORT UndefOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MLIR_UNDEF;
-  }
-
-  static std::optional<UndefOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UndefOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UndefOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UndefOp) == sizeof(Operation));
-
-class MX_EXPORT UnreachableOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_UNREACHABLE;
-  }
-
-  static std::optional<UnreachableOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UnreachableOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UnreachableOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(UnreachableOp) == sizeof(Operation));
-
-class MX_EXPORT XOrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_XOR;
-  }
-
-  static std::optional<XOrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<XOrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::XOrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(XOrOp) == sizeof(Operation));
-
-class MX_EXPORT ZExtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_ZEXT;
-  }
-
-  static std::optional<ZExtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ZExtOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ZExtOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ZExtOp) == sizeof(Operation));
-
-class MX_EXPORT ZeroOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_MLIR_ZERO;
-  }
-
-  static std::optional<ZeroOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ZeroOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ZeroOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ZeroOp) == sizeof(Operation));
-
-class MX_EXPORT AbsOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_ABS;
-  }
-
-  static std::optional<AbsOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AbsOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AbsOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  bool is_int_min_poison(void) const;
-};
-static_assert(sizeof(AbsOp) == sizeof(Operation));
-
-class MX_EXPORT AnnotationOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_ANNOTATION;
-  }
-
-  static std::optional<AnnotationOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AnnotationOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::Annotation underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> integer(void) const;
-  //::mlir::TypedValue<LLVMPointerType> annotation(void) const;
-  //::mlir::TypedValue<LLVMPointerType> file_name(void) const;
-  //::mlir::TypedValue<IntegerType> line(void) const;
-  //::mlir::TypedValue<IntegerType> result(void) const;
-};
-static_assert(sizeof(AnnotationOp) == sizeof(Operation));
-
-class MX_EXPORT AssumeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_ASSUME;
-  }
-
-  static std::optional<AssumeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AssumeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::AssumeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> cond(void) const;
-};
-static_assert(sizeof(AssumeOp) == sizeof(Operation));
-
-class MX_EXPORT BitReverseOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_BITREVERSE;
-  }
-
-  static std::optional<BitReverseOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BitReverseOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::BitReverseOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(BitReverseOp) == sizeof(Operation));
-
-class MX_EXPORT ByteSwapOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_BSWAP;
-  }
-
-  static std::optional<ByteSwapOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ByteSwapOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ByteSwapOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ByteSwapOp) == sizeof(Operation));
-
-class MX_EXPORT CopySignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_COPYSIGN;
-  }
-
-  static std::optional<CopySignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CopySignOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CopySignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(CopySignOp) == sizeof(Operation));
-
-class MX_EXPORT CoroAlignOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_ALIGN;
-  }
-
-  static std::optional<CoroAlignOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroAlignOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroAlignOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CoroAlignOp) == sizeof(Operation));
-
-class MX_EXPORT CoroBeginOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_BEGIN;
-  }
-
-  static std::optional<CoroBeginOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroBeginOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroBeginOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value token(void) const;
-  //::mlir::TypedValue<LLVMPointerType> mem(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CoroBeginOp) == sizeof(Operation));
-
-class MX_EXPORT CoroEndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_END;
-  }
-
-  static std::optional<CoroEndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroEndOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroEndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> handle(void) const;
-  //::mlir::TypedValue<IntegerType> unwind(void) const;
-  ::mx::ir::Value retvals(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CoroEndOp) == sizeof(Operation));
-
-class MX_EXPORT CoroFreeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_FREE;
-  }
-
-  static std::optional<CoroFreeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroFreeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroFreeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value id(void) const;
-  //::mlir::TypedValue<LLVMPointerType> handle(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CoroFreeOp) == sizeof(Operation));
-
-class MX_EXPORT CoroIdOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_ID;
-  }
-
-  static std::optional<CoroIdOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroIdOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroIdOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> align(void) const;
-  //::mlir::TypedValue<LLVMPointerType> promise(void) const;
-  //::mlir::TypedValue<LLVMPointerType> coroaddr(void) const;
-  //::mlir::TypedValue<LLVMPointerType> fnaddrs(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CoroIdOp) == sizeof(Operation));
-
-class MX_EXPORT CoroPromiseOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_PROMISE;
-  }
-
-  static std::optional<CoroPromiseOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroPromiseOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroPromiseOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> handle(void) const;
-  //::mlir::TypedValue<IntegerType> align(void) const;
-  //::mlir::TypedValue<IntegerType> from(void) const;
-  //::mlir::TypedValue<LLVMPointerType> result(void) const;
-};
-static_assert(sizeof(CoroPromiseOp) == sizeof(Operation));
-
-class MX_EXPORT CoroResumeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_RESUME;
-  }
-
-  static std::optional<CoroResumeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroResumeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroResumeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> handle(void) const;
-};
-static_assert(sizeof(CoroResumeOp) == sizeof(Operation));
-
-class MX_EXPORT CoroSaveOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_SAVE;
-  }
-
-  static std::optional<CoroSaveOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroSaveOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroSaveOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> handle(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CoroSaveOp) == sizeof(Operation));
-
-class MX_EXPORT CoroSizeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_SIZE;
-  }
-
-  static std::optional<CoroSizeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroSizeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroSizeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CoroSizeOp) == sizeof(Operation));
-
-class MX_EXPORT CoroSuspendOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CORO_SUSPEND;
-  }
-
-  static std::optional<CoroSuspendOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CoroSuspendOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CoroSuspendOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value save(void) const;
-  //::mlir::TypedValue<IntegerType> final(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CoroSuspendOp) == sizeof(Operation));
-
-class MX_EXPORT CosOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_COS;
-  }
-
-  static std::optional<CosOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CosOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CosOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(CosOp) == sizeof(Operation));
-
-class MX_EXPORT CountLeadingZerosOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CTLZ;
-  }
-
-  static std::optional<CountLeadingZerosOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CountLeadingZerosOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CountLeadingZerosOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  bool is_zero_poison(void) const;
-};
-static_assert(sizeof(CountLeadingZerosOp) == sizeof(Operation));
-
-class MX_EXPORT CountTrailingZerosOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CTTZ;
-  }
-
-  static std::optional<CountTrailingZerosOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CountTrailingZerosOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CountTrailingZerosOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  bool is_zero_poison(void) const;
-};
-static_assert(sizeof(CountTrailingZerosOp) == sizeof(Operation));
-
-class MX_EXPORT CtPopOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CTPOP;
-  }
-
-  static std::optional<CtPopOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CtPopOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::CtPopOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(CtPopOp) == sizeof(Operation));
-
-class MX_EXPORT DbgDeclareOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_DBG_DECLARE;
-  }
-
-  static std::optional<DbgDeclareOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DbgDeclareOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::DbgDeclareOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> addr(void) const;
-  //::mlir::LLVM::DILocalVariableAttr var_info(void) const;
-  //::mlir::LLVM::DIExpressionAttr location_expr(void) const;
-};
-static_assert(sizeof(DbgDeclareOp) == sizeof(Operation));
-
-class MX_EXPORT DbgLabelOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_DBG_LABEL;
-  }
-
-  static std::optional<DbgLabelOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DbgLabelOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::DbgLabelOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::LLVM::DILabelAttr label(void) const;
-};
-static_assert(sizeof(DbgLabelOp) == sizeof(Operation));
-
-class MX_EXPORT DbgValueOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_DBG_VALUE;
-  }
-
-  static std::optional<DbgValueOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DbgValueOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::DbgValueOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::LLVM::DILocalVariableAttr var_info(void) const;
-  //::mlir::LLVM::DIExpressionAttr location_expr(void) const;
-};
-static_assert(sizeof(DbgValueOp) == sizeof(Operation));
-
-class MX_EXPORT DebugTrapOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_DEBUGTRAP;
-  }
-
-  static std::optional<DebugTrapOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DebugTrapOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::DebugTrap underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(DebugTrapOp) == sizeof(Operation));
-
-class MX_EXPORT EhTypeidForOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_EH_TYPEID_FOR;
-  }
-
-  static std::optional<EhTypeidForOp> from(const ::mx::ir::Operation &that);
-  static std::optional<EhTypeidForOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::EhTypeidForOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> type_info(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(EhTypeidForOp) == sizeof(Operation));
-
-class MX_EXPORT Exp2Op final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_EXP2;
-  }
-
-  static std::optional<Exp2Op> from(const ::mx::ir::Operation &that);
-  static std::optional<Exp2Op> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::Exp2Op underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(Exp2Op) == sizeof(Operation));
-
-class MX_EXPORT ExpOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_EXP;
-  }
-
-  static std::optional<ExpOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExpOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ExpOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(ExpOp) == sizeof(Operation));
-
-class MX_EXPORT ExpectOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_EXPECT;
-  }
-
-  static std::optional<ExpectOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExpectOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ExpectOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> value(void) const;
-  //::mlir::TypedValue<IntegerType> expected(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ExpectOp) == sizeof(Operation));
-
-class MX_EXPORT ExpectWithProbabilityOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_EXPECT_WITH_PROBABILITY;
-  }
-
-  static std::optional<ExpectWithProbabilityOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExpectWithProbabilityOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ExpectWithProbabilityOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> value(void) const;
-  //::mlir::TypedValue<IntegerType> expected(void) const;
-  ::mx::ir::Value result(void) const;
-  //::llvm::APFloat prob(void) const;
-};
-static_assert(sizeof(ExpectWithProbabilityOp) == sizeof(Operation));
-
-class MX_EXPORT FAbsOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_FABS;
-  }
-
-  static std::optional<FAbsOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FAbsOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FAbsOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FAbsOp) == sizeof(Operation));
-
-class MX_EXPORT FCeilOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_CEIL;
-  }
-
-  static std::optional<FCeilOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FCeilOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FCeilOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FCeilOp) == sizeof(Operation));
-
-class MX_EXPORT FFloorOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_FLOOR;
-  }
-
-  static std::optional<FFloorOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FFloorOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FFloorOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FFloorOp) == sizeof(Operation));
-
-class MX_EXPORT FMAOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_FMA;
-  }
-
-  static std::optional<FMAOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FMAOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FMAOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value c(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FMAOp) == sizeof(Operation));
-
-class MX_EXPORT FMulAddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_FMULADD;
-  }
-
-  static std::optional<FMulAddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FMulAddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FMulAddOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value c(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FMulAddOp) == sizeof(Operation));
-
-class MX_EXPORT FTruncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_TRUNC;
-  }
-
-  static std::optional<FTruncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FTruncOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FTruncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FTruncOp) == sizeof(Operation));
-
-class MX_EXPORT FShlOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_FSHL;
-  }
-
-  static std::optional<FShlOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FShlOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FshlOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value c(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(FShlOp) == sizeof(Operation));
-
-class MX_EXPORT FShrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_FSHR;
-  }
-
-  static std::optional<FShrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FShrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::FshrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value c(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(FShrOp) == sizeof(Operation));
-
-class MX_EXPORT GetActiveLaneMaskOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_GET_ACTIVE_LANE_MASK;
-  }
-
-  static std::optional<GetActiveLaneMaskOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GetActiveLaneMaskOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::GetActiveLaneMaskOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> base(void) const;
-  //::mlir::TypedValue<IntegerType> n(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(GetActiveLaneMaskOp) == sizeof(Operation));
-
-class MX_EXPORT InvariantEndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_INVARIANT_END;
-  }
-
-  static std::optional<InvariantEndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InvariantEndOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::InvariantEndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> start(void) const;
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  uint64_t size(void) const;
-};
-static_assert(sizeof(InvariantEndOp) == sizeof(Operation));
-
-class MX_EXPORT InvariantStartOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_INVARIANT_START;
-  }
-
-  static std::optional<InvariantStartOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InvariantStartOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::InvariantStartOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  //::mlir::TypedValue<LLVMPointerType> result(void) const;
-  uint64_t size(void) const;
-};
-static_assert(sizeof(InvariantStartOp) == sizeof(Operation));
-
-class MX_EXPORT IsConstantOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_IS_CONSTANT;
-  }
-
-  static std::optional<IsConstantOp> from(const ::mx::ir::Operation &that);
-  static std::optional<IsConstantOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::IsConstantOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<IntegerType> result(void) const;
-};
-static_assert(sizeof(IsConstantOp) == sizeof(Operation));
-
-class MX_EXPORT IsFPClassOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_IS_FPCLASS;
-  }
-
-  static std::optional<IsFPClassOp> from(const ::mx::ir::Operation &that);
-  static std::optional<IsFPClassOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::IsFPClass underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  uint32_t bit(void) const;
-};
-static_assert(sizeof(IsFPClassOp) == sizeof(Operation));
-
-class MX_EXPORT LifetimeEndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_LIFETIME_END;
-  }
-
-  static std::optional<LifetimeEndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LifetimeEndOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LifetimeEndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  uint64_t size(void) const;
-};
-static_assert(sizeof(LifetimeEndOp) == sizeof(Operation));
-
-class MX_EXPORT LifetimeStartOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_LIFETIME_START;
-  }
-
-  static std::optional<LifetimeStartOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LifetimeStartOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LifetimeStartOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  uint64_t size(void) const;
-};
-static_assert(sizeof(LifetimeStartOp) == sizeof(Operation));
-
-class MX_EXPORT RoundAndCastToLongLongOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_LLRINT;
-  }
-
-  static std::optional<RoundAndCastToLongLongOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RoundAndCastToLongLongOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LlrintOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RoundAndCastToLongLongOp) == sizeof(Operation));
-
-class MX_EXPORT RoundAndCastToNearestLongLongOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_LLROUND;
-  }
-
-  static std::optional<RoundAndCastToNearestLongLongOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RoundAndCastToNearestLongLongOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LlroundOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RoundAndCastToNearestLongLongOp) == sizeof(Operation));
-
-class MX_EXPORT Log10Op final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_LOG10;
-  }
-
-  static std::optional<Log10Op> from(const ::mx::ir::Operation &that);
-  static std::optional<Log10Op> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::Log10Op underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(Log10Op) == sizeof(Operation));
-
-class MX_EXPORT Log2Op final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_LOG2;
-  }
-
-  static std::optional<Log2Op> from(const ::mx::ir::Operation &that);
-  static std::optional<Log2Op> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::Log2Op underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(Log2Op) == sizeof(Operation));
-
-class MX_EXPORT LogOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_LOG;
-  }
-
-  static std::optional<LogOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LogOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LogOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(LogOp) == sizeof(Operation));
-
-class MX_EXPORT RoundAndCastToLongOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_LRINT;
-  }
-
-  static std::optional<RoundAndCastToLongOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RoundAndCastToLongOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LrintOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RoundAndCastToLongOp) == sizeof(Operation));
-
-class MX_EXPORT RoundAndCastToNearestLongOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_LROUND;
-  }
-
-  static std::optional<RoundAndCastToNearestLongOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RoundAndCastToNearestLongOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::LroundOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(RoundAndCastToNearestLongOp) == sizeof(Operation));
-
-class MX_EXPORT MaskedLoadOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MASKED_LOAD;
-  }
-
-  static std::optional<MaskedLoadOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MaskedLoadOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MaskedLoadOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> data(void) const;
-  ::mx::ir::Value mask(void) const;
-  gap::generator<::mx::ir::Operand> pass_thru(void) const &;
-  ::mx::ir::Value result(void) const;
-  uint32_t alignment(void) const;
-};
-static_assert(sizeof(MaskedLoadOp) == sizeof(Operation));
-
-class MX_EXPORT MaskedStoreOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MASKED_STORE;
-  }
-
-  static std::optional<MaskedStoreOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MaskedStoreOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MaskedStoreOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<LLVMPointerType> data(void) const;
-  ::mx::ir::Value mask(void) const;
-  uint32_t alignment(void) const;
-};
-static_assert(sizeof(MaskedStoreOp) == sizeof(Operation));
-
-class MX_EXPORT MatrixColumnMajorLoadOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_LOAD;
-  }
-
-  static std::optional<MatrixColumnMajorLoadOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MatrixColumnMajorLoadOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MatrixColumnMajorLoadOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> data(void) const;
-  //::mlir::TypedValue<IntegerType> stride(void) const;
-  ::mx::ir::Value result(void) const;
-  bool is_volatile(void) const;
-  uint32_t rows(void) const;
-  uint32_t columns(void) const;
-};
-static_assert(sizeof(MatrixColumnMajorLoadOp) == sizeof(Operation));
-
-class MX_EXPORT MatrixColumnMajorStoreOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_STORE;
-  }
-
-  static std::optional<MatrixColumnMajorStoreOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MatrixColumnMajorStoreOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MatrixColumnMajorStoreOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value matrix(void) const;
-  //::mlir::TypedValue<LLVMPointerType> data(void) const;
-  //::mlir::TypedValue<IntegerType> stride(void) const;
-  bool is_volatile(void) const;
-  uint32_t rows(void) const;
-  uint32_t columns(void) const;
-};
-static_assert(sizeof(MatrixColumnMajorStoreOp) == sizeof(Operation));
-
-class MX_EXPORT MatrixMultiplyOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MATRIX_MULTIPLY;
-  }
-
-  static std::optional<MatrixMultiplyOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MatrixMultiplyOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MatrixMultiplyOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value result(void) const;
-  uint32_t lhs_rows(void) const;
-  uint32_t lhs_columns(void) const;
-  uint32_t rhs_columns(void) const;
-};
-static_assert(sizeof(MatrixMultiplyOp) == sizeof(Operation));
-
-class MX_EXPORT MatrixTransposeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MATRIX_TRANSPOSE;
-  }
-
-  static std::optional<MatrixTransposeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MatrixTransposeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MatrixTransposeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value matrix(void) const;
-  ::mx::ir::Value result(void) const;
-  uint32_t rows(void) const;
-  uint32_t columns(void) const;
-};
-static_assert(sizeof(MatrixTransposeOp) == sizeof(Operation));
-
-class MX_EXPORT MaxNumOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MAXNUM;
-  }
-
-  static std::optional<MaxNumOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MaxNumOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MaxNumOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(MaxNumOp) == sizeof(Operation));
-
-class MX_EXPORT MaximumOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MAXIMUM;
-  }
-
-  static std::optional<MaximumOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MaximumOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MaximumOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(MaximumOp) == sizeof(Operation));
-
-class MX_EXPORT MemcpyInlineOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MEMCPY_INLINE;
-  }
-
-  static std::optional<MemcpyInlineOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MemcpyInlineOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MemcpyInlineOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> destination(void) const;
-  //::mlir::TypedValue<LLVMPointerType> source(void) const;
-  //::mlir::APInt len(void) const;
-  bool is_volatile(void) const;
-  //::std::optional<ArrayAttr> access_groups(void) const;
-  //::std::optional<ArrayAttr> alias_scopes(void) const;
-  //::std::optional<ArrayAttr> noalias_scopes(void) const;
-  //::std::optional<ArrayAttr> tbaa(void) const;
-  //::llvm::SmallVector<Value, 6> accessed_operands(void) const;
-};
-static_assert(sizeof(MemcpyInlineOp) == sizeof(Operation));
-
-class MX_EXPORT MemcpyOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MEMCPY;
-  }
-
-  static std::optional<MemcpyOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MemcpyOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MemcpyOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> destination(void) const;
-  //::mlir::TypedValue<LLVMPointerType> source(void) const;
-  //::mlir::TypedValue<IntegerType> len(void) const;
-  bool is_volatile(void) const;
-  //::std::optional<ArrayAttr> access_groups(void) const;
-  //::std::optional<ArrayAttr> alias_scopes(void) const;
-  //::std::optional<ArrayAttr> noalias_scopes(void) const;
-  //::std::optional<ArrayAttr> tbaa(void) const;
-  //::llvm::SmallVector<Value, 6> accessed_operands(void) const;
-};
-static_assert(sizeof(MemcpyOp) == sizeof(Operation));
-
-class MX_EXPORT MemmoveOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MEMMOVE;
-  }
-
-  static std::optional<MemmoveOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MemmoveOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MemmoveOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> destination(void) const;
-  //::mlir::TypedValue<LLVMPointerType> source(void) const;
-  //::mlir::TypedValue<IntegerType> len(void) const;
-  bool is_volatile(void) const;
-  //::std::optional<ArrayAttr> access_groups(void) const;
-  //::std::optional<ArrayAttr> alias_scopes(void) const;
-  //::std::optional<ArrayAttr> noalias_scopes(void) const;
-  //::std::optional<ArrayAttr> tbaa(void) const;
-  //::llvm::SmallVector<Value, 6> accessed_operands(void) const;
-};
-static_assert(sizeof(MemmoveOp) == sizeof(Operation));
-
-class MX_EXPORT MemsetOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MEMSET;
-  }
-
-  static std::optional<MemsetOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MemsetOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MemsetOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> destination(void) const;
-  //::mlir::TypedValue<IntegerType> value(void) const;
-  //::mlir::TypedValue<IntegerType> len(void) const;
-  bool is_volatile(void) const;
-  //::std::optional<ArrayAttr> access_groups(void) const;
-  //::std::optional<ArrayAttr> alias_scopes(void) const;
-  //::std::optional<ArrayAttr> noalias_scopes(void) const;
-  //::std::optional<ArrayAttr> tbaa(void) const;
-  //::llvm::SmallVector<Value, 6> accessed_operands(void) const;
-};
-static_assert(sizeof(MemsetOp) == sizeof(Operation));
-
-class MX_EXPORT MinNumOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MINNUM;
-  }
-
-  static std::optional<MinNumOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MinNumOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MinNumOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(MinNumOp) == sizeof(Operation));
-
-class MX_EXPORT MinimumOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MINIMUM;
-  }
-
-  static std::optional<MinimumOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MinimumOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::MinimumOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(MinimumOp) == sizeof(Operation));
-
-class MX_EXPORT RoundToNearbyIntOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_NEARBYINT;
-  }
-
-  static std::optional<RoundToNearbyIntOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RoundToNearbyIntOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::NearbyintOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(RoundToNearbyIntOp) == sizeof(Operation));
-
-class MX_EXPORT NoAliasScopeDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_EXPERIMENTAL_NOALIAS_SCOPE_DECL;
-  }
-
-  static std::optional<NoAliasScopeDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<NoAliasScopeDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::NoAliasScopeDeclOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::LLVM::AliasScopeAttr scope(void) const;
-};
-static_assert(sizeof(NoAliasScopeDeclOp) == sizeof(Operation));
-
-class MX_EXPORT PowIOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_POWI;
-  }
-
-  static std::optional<PowIOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PowIOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::PowIOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<IntegerType> power(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(PowIOp) == sizeof(Operation));
-
-class MX_EXPORT FPowOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_POW;
-  }
-
-  static std::optional<FPowOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FPowOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::PowOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(FPowOp) == sizeof(Operation));
-
-class MX_EXPORT PrefetchOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_PREFETCH;
-  }
-
-  static std::optional<PrefetchOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PrefetchOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::Prefetch underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> addr(void) const;
-  uint32_t rw(void) const;
-  uint32_t hint(void) const;
-  uint32_t cache(void) const;
-};
-static_assert(sizeof(PrefetchOp) == sizeof(Operation));
-
-class MX_EXPORT PtrAnnotationOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_PTR_ANNOTATION;
-  }
-
-  static std::optional<PtrAnnotationOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PtrAnnotationOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::PtrAnnotation underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  //::mlir::TypedValue<LLVMPointerType> annotation(void) const;
-  //::mlir::TypedValue<LLVMPointerType> file_name(void) const;
-  //::mlir::TypedValue<IntegerType> line(void) const;
-  //::mlir::TypedValue<LLVMPointerType> attr(void) const;
-  //::mlir::TypedValue<LLVMPointerType> result(void) const;
-};
-static_assert(sizeof(PtrAnnotationOp) == sizeof(Operation));
-
-class MX_EXPORT RoundToIntOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_RINT;
-  }
-
-  static std::optional<RoundToIntOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RoundToIntOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::RintOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(RoundToIntOp) == sizeof(Operation));
-
-class MX_EXPORT RoundToNearestEvenOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_ROUNDEVEN;
-  }
-
-  static std::optional<RoundToNearestEvenOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RoundToNearestEvenOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::RoundEvenOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(RoundToNearestEvenOp) == sizeof(Operation));
-
-class MX_EXPORT RoundToNearestOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_ROUND;
-  }
-
-  static std::optional<RoundToNearestOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RoundToNearestOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::RoundOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(RoundToNearestOp) == sizeof(Operation));
-
-class MX_EXPORT SAddSatOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SADD_SAT;
-  }
-
-  static std::optional<SAddSatOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SAddSatOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SAddSat underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SAddSatOp) == sizeof(Operation));
-
-class MX_EXPORT SAddWithOverflowOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SADD_WITH_OVERFLOW;
-  }
-
-  static std::optional<SAddWithOverflowOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SAddWithOverflowOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SAddWithOverflowOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SAddWithOverflowOp) == sizeof(Operation));
-
-class MX_EXPORT SMaxOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SMAX;
-  }
-
-  static std::optional<SMaxOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SMaxOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SMaxOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SMaxOp) == sizeof(Operation));
-
-class MX_EXPORT SMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SMIN;
-  }
-
-  static std::optional<SMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SMinOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SMinOp) == sizeof(Operation));
-
-class MX_EXPORT SMulWithOverflowOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SMUL_WITH_OVERFLOW;
-  }
-
-  static std::optional<SMulWithOverflowOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SMulWithOverflowOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SMulWithOverflowOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SMulWithOverflowOp) == sizeof(Operation));
-
-class MX_EXPORT SSACopyOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SSA_COPY;
-  }
-
-  static std::optional<SSACopyOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SSACopyOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SSACopyOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value operand(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SSACopyOp) == sizeof(Operation));
-
-class MX_EXPORT SShlSatOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SSHL_SAT;
-  }
-
-  static std::optional<SShlSatOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SShlSatOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SSHLSat underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SShlSatOp) == sizeof(Operation));
-
-class MX_EXPORT SSubSatOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SSUB_SAT;
-  }
-
-  static std::optional<SSubSatOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SSubSatOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SSubSat underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SSubSatOp) == sizeof(Operation));
-
-class MX_EXPORT SSubWithOverflowOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SSUB_WITH_OVERFLOW;
-  }
-
-  static std::optional<SSubWithOverflowOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SSubWithOverflowOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SSubWithOverflowOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SSubWithOverflowOp) == sizeof(Operation));
-
-class MX_EXPORT SinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SIN;
-  }
-
-  static std::optional<SinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SinOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(SinOp) == sizeof(Operation));
-
-class MX_EXPORT SqrtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_SQRT;
-  }
-
-  static std::optional<SqrtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SqrtOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::SqrtOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(SqrtOp) == sizeof(Operation));
-
-class MX_EXPORT StackRestoreOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_STACKRESTORE;
-  }
-
-  static std::optional<StackRestoreOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StackRestoreOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::StackRestoreOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-};
-static_assert(sizeof(StackRestoreOp) == sizeof(Operation));
-
-class MX_EXPORT StackSaveOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_STACKSAVE;
-  }
-
-  static std::optional<StackSaveOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StackSaveOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::StackSaveOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(StackSaveOp) == sizeof(Operation));
-
-class MX_EXPORT StepVectorOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_EXPERIMENTAL_STEPVECTOR;
-  }
-
-  static std::optional<StepVectorOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StepVectorOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::StepVectorOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(StepVectorOp) == sizeof(Operation));
-
-class MX_EXPORT ThreadLocalAddressOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_THREADLOCAL_ADDRESS;
-  }
-
-  static std::optional<ThreadLocalAddressOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ThreadLocalAddressOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::ThreadlocalAddressOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> global(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ThreadLocalAddressOp) == sizeof(Operation));
-
-class MX_EXPORT TrapOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_TRAP;
-  }
-
-  static std::optional<TrapOp> from(const ::mx::ir::Operation &that);
-  static std::optional<TrapOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::Trap underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(TrapOp) == sizeof(Operation));
-
-class MX_EXPORT UAddSatOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_UADD_SAT;
-  }
-
-  static std::optional<UAddSatOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UAddSatOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UAddSat underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UAddSatOp) == sizeof(Operation));
-
-class MX_EXPORT UAddWithOverflowOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_UADD_WITH_OVERFLOW;
-  }
-
-  static std::optional<UAddWithOverflowOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UAddWithOverflowOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UAddWithOverflowOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UAddWithOverflowOp) == sizeof(Operation));
-
-class MX_EXPORT UBSanTrapOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_UBSANTRAP;
-  }
-
-  static std::optional<UBSanTrapOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UBSanTrapOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UBSanTrap underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  uint8_t failure_kind(void) const;
-};
-static_assert(sizeof(UBSanTrapOp) == sizeof(Operation));
-
-class MX_EXPORT UMaxOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_UMAX;
-  }
-
-  static std::optional<UMaxOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UMaxOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UMaxOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UMaxOp) == sizeof(Operation));
-
-class MX_EXPORT UMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_UMIN;
-  }
-
-  static std::optional<UMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UMinOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UMinOp) == sizeof(Operation));
-
-class MX_EXPORT UMulWithOverflowOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_UMUL_WITH_OVERFLOW;
-  }
-
-  static std::optional<UMulWithOverflowOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UMulWithOverflowOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::UMulWithOverflowOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UMulWithOverflowOp) == sizeof(Operation));
-
-class MX_EXPORT UShlSatOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_USHL_SAT;
-  }
-
-  static std::optional<UShlSatOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UShlSatOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::USHLSat underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UShlSatOp) == sizeof(Operation));
-
-class MX_EXPORT USubSatOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_USUB_SAT;
-  }
-
-  static std::optional<USubSatOp> from(const ::mx::ir::Operation &that);
-  static std::optional<USubSatOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::USubSat underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value a(void) const;
-  ::mx::ir::Value b(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(USubSatOp) == sizeof(Operation));
-
-class MX_EXPORT USubWithOverflowOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_USUB_WITH_OVERFLOW;
-  }
-
-  static std::optional<USubWithOverflowOp> from(const ::mx::ir::Operation &that);
-  static std::optional<USubWithOverflowOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::USubWithOverflowOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(USubWithOverflowOp) == sizeof(Operation));
-
-class MX_EXPORT VPAShrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_ASHR;
-  }
-
-  static std::optional<VPAShrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPAShrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPAShrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPAShrOp) == sizeof(Operation));
-
-class MX_EXPORT VPAddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_ADD;
-  }
-
-  static std::optional<VPAddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPAddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPAddOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPAddOp) == sizeof(Operation));
-
-class MX_EXPORT VPAndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_AND;
-  }
-
-  static std::optional<VPAndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPAndOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPAndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPAndOp) == sizeof(Operation));
-
-class MX_EXPORT VPFAddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FADD;
-  }
-
-  static std::optional<VPFAddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFAddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFAddOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFAddOp) == sizeof(Operation));
-
-class MX_EXPORT VPFDivOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FDIV;
-  }
-
-  static std::optional<VPFDivOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFDivOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFDivOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFDivOp) == sizeof(Operation));
-
-class MX_EXPORT VPFMulAddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FMULADD;
-  }
-
-  static std::optional<VPFMulAddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFMulAddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFMulAddOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value op1(void) const;
-  ::mx::ir::Value op2(void) const;
-  ::mx::ir::Value op3(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFMulAddOp) == sizeof(Operation));
-
-class MX_EXPORT VPFMulOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FMUL;
-  }
-
-  static std::optional<VPFMulOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFMulOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFMulOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFMulOp) == sizeof(Operation));
-
-class MX_EXPORT VPFNegOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FNEG;
-  }
-
-  static std::optional<VPFNegOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFNegOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFNegOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value op(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFNegOp) == sizeof(Operation));
-
-class MX_EXPORT VPFPExtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FPEXT;
-  }
-
-  static std::optional<VPFPExtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFPExtOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFPExtOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFPExtOp) == sizeof(Operation));
-
-class MX_EXPORT VPFPToSIOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FPTOSI;
-  }
-
-  static std::optional<VPFPToSIOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFPToSIOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFPToSIOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFPToSIOp) == sizeof(Operation));
-
-class MX_EXPORT VPFPToUIOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FPTOUI;
-  }
-
-  static std::optional<VPFPToUIOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFPToUIOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFPToUIOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFPToUIOp) == sizeof(Operation));
-
-class MX_EXPORT VPFPTruncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FPTRUNC;
-  }
-
-  static std::optional<VPFPTruncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFPTruncOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFPTruncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFPTruncOp) == sizeof(Operation));
-
-class MX_EXPORT VPFRemOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FREM;
-  }
-
-  static std::optional<VPFRemOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFRemOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFRemOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFRemOp) == sizeof(Operation));
-
-class MX_EXPORT VPFSubOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FSUB;
-  }
-
-  static std::optional<VPFSubOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFSubOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFSubOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFSubOp) == sizeof(Operation));
-
-class MX_EXPORT VPFmaOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_FMA;
-  }
-
-  static std::optional<VPFmaOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPFmaOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPFmaOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value op1(void) const;
-  ::mx::ir::Value op2(void) const;
-  ::mx::ir::Value op3(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPFmaOp) == sizeof(Operation));
-
-class MX_EXPORT VPIntToPtrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_INTTOPTR;
-  }
-
-  static std::optional<VPIntToPtrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPIntToPtrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPIntToPtrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPIntToPtrOp) == sizeof(Operation));
-
-class MX_EXPORT VPLShrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_LSHR;
-  }
-
-  static std::optional<VPLShrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPLShrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPLShrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPLShrOp) == sizeof(Operation));
-
-class MX_EXPORT VPLoadOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_LOAD;
-  }
-
-  static std::optional<VPLoadOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPLoadOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPLoadOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPLoadOp) == sizeof(Operation));
-
-class MX_EXPORT VPMergeMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_MERGE;
-  }
-
-  static std::optional<VPMergeMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPMergeMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPMergeMinOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value cond(void) const;
-  ::mx::ir::Value true_val(void) const;
-  ::mx::ir::Value false_val(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPMergeMinOp) == sizeof(Operation));
-
-class MX_EXPORT VPMulOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_MUL;
-  }
-
-  static std::optional<VPMulOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPMulOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPMulOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPMulOp) == sizeof(Operation));
-
-class MX_EXPORT VPOrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_OR;
-  }
-
-  static std::optional<VPOrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPOrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPOrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPOrOp) == sizeof(Operation));
-
-class MX_EXPORT VPPtrToIntOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_PTRTOINT;
-  }
-
-  static std::optional<VPPtrToIntOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPPtrToIntOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPPtrToIntOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPPtrToIntOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceAddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_ADD;
-  }
-
-  static std::optional<VPReduceAddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceAddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceAddOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceAddOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceAndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_AND;
-  }
-
-  static std::optional<VPReduceAndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceAndOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceAndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceAndOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceFAddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_FADD;
-  }
-
-  static std::optional<VPReduceFAddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceFAddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceFAddOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<FloatType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceFAddOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceFMaxOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_FMAX;
-  }
-
-  static std::optional<VPReduceFMaxOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceFMaxOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceFMaxOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<FloatType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceFMaxOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceFMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_FMIN;
-  }
-
-  static std::optional<VPReduceFMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceFMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceFMinOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<FloatType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceFMinOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceFMulOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_FMUL;
-  }
-
-  static std::optional<VPReduceFMulOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceFMulOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceFMulOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<FloatType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceFMulOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceMulOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_MUL;
-  }
-
-  static std::optional<VPReduceMulOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceMulOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceMulOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceMulOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceOrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_OR;
-  }
-
-  static std::optional<VPReduceOrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceOrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceOrOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceOrOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceSMaxOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_SMAX;
-  }
-
-  static std::optional<VPReduceSMaxOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceSMaxOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceSMaxOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceSMaxOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceSMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_SMIN;
-  }
-
-  static std::optional<VPReduceSMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceSMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceSMinOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceSMinOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceUMaxOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_UMAX;
-  }
-
-  static std::optional<VPReduceUMaxOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceUMaxOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceUMaxOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceUMaxOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceUMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_UMIN;
-  }
-
-  static std::optional<VPReduceUMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceUMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceUMinOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceUMinOp) == sizeof(Operation));
-
-class MX_EXPORT VPReduceXorOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_REDUCE_XOR;
-  }
-
-  static std::optional<VPReduceXorOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPReduceXorOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPReduceXorOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<IntegerType> satrt_value(void) const;
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPReduceXorOp) == sizeof(Operation));
-
-class MX_EXPORT VPSDivOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_SDIV;
-  }
-
-  static std::optional<VPSDivOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPSDivOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPSDivOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPSDivOp) == sizeof(Operation));
-
-class MX_EXPORT VPSExtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_SEXT;
-  }
-
-  static std::optional<VPSExtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPSExtOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPSExtOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPSExtOp) == sizeof(Operation));
-
-class MX_EXPORT VPSIToFPOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_SITOFP;
-  }
-
-  static std::optional<VPSIToFPOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPSIToFPOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPSIToFPOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPSIToFPOp) == sizeof(Operation));
-
-class MX_EXPORT VPSRemOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_SREM;
-  }
-
-  static std::optional<VPSRemOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPSRemOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPSRemOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPSRemOp) == sizeof(Operation));
-
-class MX_EXPORT VPSelectMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_SELECT;
-  }
-
-  static std::optional<VPSelectMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPSelectMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPSelectMinOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value cond(void) const;
-  ::mx::ir::Value true_val(void) const;
-  ::mx::ir::Value false_val(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPSelectMinOp) == sizeof(Operation));
-
-class MX_EXPORT VPShlOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_SHL;
-  }
-
-  static std::optional<VPShlOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPShlOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPShlOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPShlOp) == sizeof(Operation));
-
-class MX_EXPORT VPStoreOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_STORE;
-  }
-
-  static std::optional<VPStoreOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPStoreOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPStoreOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-};
-static_assert(sizeof(VPStoreOp) == sizeof(Operation));
-
-class MX_EXPORT VPStridedLoadOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_LOAD;
-  }
-
-  static std::optional<VPStridedLoadOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPStridedLoadOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPStridedLoadOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  //::mlir::TypedValue<IntegerType> stride(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPStridedLoadOp) == sizeof(Operation));
-
-class MX_EXPORT VPStridedStoreOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_STORE;
-  }
-
-  static std::optional<VPStridedStoreOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPStridedStoreOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPStridedStoreOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<LLVMPointerType> ptr(void) const;
-  //::mlir::TypedValue<IntegerType> stride(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-};
-static_assert(sizeof(VPStridedStoreOp) == sizeof(Operation));
-
-class MX_EXPORT VPSubOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_SUB;
-  }
-
-  static std::optional<VPSubOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPSubOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPSubOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPSubOp) == sizeof(Operation));
-
-class MX_EXPORT VPTruncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_TRUNC;
-  }
-
-  static std::optional<VPTruncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPTruncOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPTruncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPTruncOp) == sizeof(Operation));
-
-class MX_EXPORT VPUDivOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_UDIV;
-  }
-
-  static std::optional<VPUDivOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPUDivOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPUDivOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPUDivOp) == sizeof(Operation));
-
-class MX_EXPORT VPUIToFPOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_UITOFP;
-  }
-
-  static std::optional<VPUIToFPOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPUIToFPOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPUIToFPOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPUIToFPOp) == sizeof(Operation));
-
-class MX_EXPORT VPURemOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_UREM;
-  }
-
-  static std::optional<VPURemOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPURemOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPURemOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPURemOp) == sizeof(Operation));
-
-class MX_EXPORT VPXorOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_XOR;
-  }
-
-  static std::optional<VPXorOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPXorOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPXorOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value left(void) const;
-  ::mx::ir::Value right(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPXorOp) == sizeof(Operation));
-
-class MX_EXPORT VPZExtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VP_ZEXT;
-  }
-
-  static std::optional<VPZExtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VPZExtOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VPZExtOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  ::mx::ir::Value mask(void) const;
-  //::mlir::TypedValue<IntegerType> evl(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VPZExtOp) == sizeof(Operation));
-
-class MX_EXPORT VaCopyOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VACOPY;
-  }
-
-  static std::optional<VaCopyOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VaCopyOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VaCopyOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> dest_list(void) const;
-  //::mlir::TypedValue<LLVMPointerType> src_list(void) const;
-};
-static_assert(sizeof(VaCopyOp) == sizeof(Operation));
-
-class MX_EXPORT VaEndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VAEND;
-  }
-
-  static std::optional<VaEndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VaEndOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VaEndOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> argument_list(void) const;
-};
-static_assert(sizeof(VaEndOp) == sizeof(Operation));
-
-class MX_EXPORT VaStartOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VASTART;
-  }
-
-  static std::optional<VaStartOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VaStartOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VaStartOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> argument_list(void) const;
-};
-static_assert(sizeof(VaStartOp) == sizeof(Operation));
-
-class MX_EXPORT VarAnnotationOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VAR_ANNOTATION;
-  }
-
-  static std::optional<VarAnnotationOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VarAnnotationOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::VarAnnotation underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<LLVMPointerType> value(void) const;
-  //::mlir::TypedValue<LLVMPointerType> annotation(void) const;
-  //::mlir::TypedValue<LLVMPointerType> file_name(void) const;
-  //::mlir::TypedValue<IntegerType> line(void) const;
-  //::mlir::TypedValue<LLVMPointerType> attr(void) const;
-};
-static_assert(sizeof(VarAnnotationOp) == sizeof(Operation));
-
-class MX_EXPORT MaskedCompressStoreOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MASKED_COMPRESSSTORE;
-  }
-
-  static std::optional<MaskedCompressStoreOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MaskedCompressStoreOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::masked_compressstore underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(MaskedCompressStoreOp) == sizeof(Operation));
-
-class MX_EXPORT MaskedExpandLoadOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MASKED_EXPANDLOAD;
-  }
-
-  static std::optional<MaskedExpandLoadOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MaskedExpandLoadOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::masked_expandload underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(MaskedExpandLoadOp) == sizeof(Operation));
-
-class MX_EXPORT MaskedGatherOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MASKED_GATHER;
-  }
-
-  static std::optional<MaskedGatherOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MaskedGatherOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::masked_gather underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value ptrs(void) const;
-  ::mx::ir::Value mask(void) const;
-  gap::generator<::mx::ir::Operand> pass_thru(void) const &;
-  ::mx::ir::Value result(void) const;
-  uint32_t alignment(void) const;
-};
-static_assert(sizeof(MaskedGatherOp) == sizeof(Operation));
-
-class MX_EXPORT MaskedScatterOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_MASKED_SCATTER;
-  }
-
-  static std::optional<MaskedScatterOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MaskedScatterOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::masked_scatter underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  ::mx::ir::Value ptrs(void) const;
-  ::mx::ir::Value mask(void) const;
-  uint32_t alignment(void) const;
-};
-static_assert(sizeof(MaskedScatterOp) == sizeof(Operation));
-
-class MX_EXPORT VectorExtractOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_EXTRACT;
-  }
-
-  static std::optional<VectorExtractOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorExtractOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_extract underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value srcvec(void) const;
-  ::mx::ir::Value result(void) const;
-  uint64_t pos(void) const;
-  uint64_t src_vector_bit_width(void) const;
-  uint64_t res_vector_bit_width(void) const;
-};
-static_assert(sizeof(VectorExtractOp) == sizeof(Operation));
-
-class MX_EXPORT VectorInsertOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_INSERT;
-  }
-
-  static std::optional<VectorInsertOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorInsertOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_insert underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value dstvec(void) const;
-  ::mx::ir::Value srcvec(void) const;
-  ::mx::ir::Value result(void) const;
-  uint64_t pos(void) const;
-  uint64_t src_vector_bit_width(void) const;
-  uint64_t dst_vector_bit_width(void) const;
-};
-static_assert(sizeof(VectorInsertOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceAddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_ADD;
-  }
-
-  static std::optional<VectorReduceAddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceAddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_add underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VectorReduceAddOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceAndOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_AND;
-  }
-
-  static std::optional<VectorReduceAndOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceAndOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_and underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VectorReduceAndOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceFAddOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_FADD;
-  }
-
-  static std::optional<VectorReduceFAddOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceFAddOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_fadd underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<FloatType> start_value(void) const;
-  ::mx::ir::Value input(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(VectorReduceFAddOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceFMaxOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAX;
-  }
-
-  static std::optional<VectorReduceFMaxOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceFMaxOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_fmax underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(VectorReduceFMaxOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceFMaximumOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAXIMUM;
-  }
-
-  static std::optional<VectorReduceFMaximumOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceFMaximumOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_fmaximum underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(VectorReduceFMaximumOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceFMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_FMIN;
-  }
-
-  static std::optional<VectorReduceFMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceFMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_fmin underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(VectorReduceFMinOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceFMinimumOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_FMINIMUM;
-  }
-
-  static std::optional<VectorReduceFMinimumOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceFMinimumOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_fminimum underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(VectorReduceFMinimumOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceFMulOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_FMUL;
-  }
-
-  static std::optional<VectorReduceFMulOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceFMulOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_fmul underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<FloatType> start_value(void) const;
-  ::mx::ir::Value input(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::LLVM::FastmathFlags fastmath_flags(void) const;
-};
-static_assert(sizeof(VectorReduceFMulOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceMulOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_MUL;
-  }
-
-  static std::optional<VectorReduceMulOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceMulOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_mul underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VectorReduceMulOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceOrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_OR;
-  }
-
-  static std::optional<VectorReduceOrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceOrOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_or underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VectorReduceOrOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceSMaxOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_SMAX;
-  }
-
-  static std::optional<VectorReduceSMaxOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceSMaxOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_smax underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VectorReduceSMaxOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceSMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_SMIN;
-  }
-
-  static std::optional<VectorReduceSMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceSMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_smin underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VectorReduceSMinOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceUMaxOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_UMAX;
-  }
-
-  static std::optional<VectorReduceUMaxOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceUMaxOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_umax underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VectorReduceUMaxOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceUMinOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_UMIN;
-  }
-
-  static std::optional<VectorReduceUMinOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceUMinOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_umin underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VectorReduceUMinOp) == sizeof(Operation));
-
-class MX_EXPORT VectorReduceXorOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VECTOR_REDUCE_XOR;
-  }
-
-  static std::optional<VectorReduceXorOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VectorReduceXorOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vector_reduce_xor underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value in(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VectorReduceXorOp) == sizeof(Operation));
-
-class MX_EXPORT VScaleOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LLVM_INTR_VSCALE;
-  }
-
-  static std::optional<VScaleOp> from(const ::mx::ir::Operation &that);
-  static std::optional<VScaleOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::LLVM::vscale underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(VScaleOp) == sizeof(Operation));
-
-}  // namespace mx::ir::llvm
diff --git a/include/multiplier/IR/LLVM/Type.h b/include/multiplier/IR/LLVM/Type.h
deleted file mode 100644
index 8c616621e..000000000
--- a/include/multiplier/IR/LLVM/Type.h
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Type.h"
-
-namespace mlir::LLVM {
-class LLVMArrayType;
-class LLVMFunctionType;
-class LLVMPointerType;
-class LLVMFixedVectorType;
-class LLVMScalableVectorType;
-class LLVMTargetExtType;
-}  // namespace mlir::LLVM
-namespace mx::ir::llvm {
-
-class MX_EXPORT Type : public ::mx::ir::Type {
- public:
-  static std::optional<Type> from(const ::mx::ir::Type &);
-};
-static_assert(sizeof(Type) == sizeof(::mx::ir::Type));
-
-class MX_EXPORT ArrayType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::LLVM_ARRAY;
-  }
-
-  static std::optional<ArrayType> from(const ::mx::ir::Type &that);
-  ::mlir::LLVM::LLVMArrayType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-  unsigned int num_elements(void) const;
-  //::std::optional<DenseMap<Attribute, Type, DenseMapInfo<Attribute, void>, DenseMapPair<Attribute, Type>>> subelement_index_map(void) const;
-};
-static_assert(sizeof(ArrayType) == sizeof(Type));
-
-class MX_EXPORT FunctionType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::LLVM_FUNCTION;
-  }
-
-  static std::optional<FunctionType> from(const ::mx::ir::Type &that);
-  ::mlir::LLVM::LLVMFunctionType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool is_var_arg(void) const;
-  //ArrayRef<Type> return_types(void) const;
-  unsigned int num_params(void) const;
-  //Type return_type(void) const;
-  gap::generator<::mx::ir::Type> params(void) const &;
-  bool var_arg(void) const;
-};
-static_assert(sizeof(FunctionType) == sizeof(Type));
-
-class MX_EXPORT PointerType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::LLVM_POINTER;
-  }
-
-  static std::optional<PointerType> from(const ::mx::ir::Type &that);
-  ::mlir::LLVM::LLVMPointerType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  unsigned int address_space(void) const;
-};
-static_assert(sizeof(PointerType) == sizeof(Type));
-
-class MX_EXPORT FixedVectorType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::LLVM_FIXED_VECTOR;
-  }
-
-  static std::optional<FixedVectorType> from(const ::mx::ir::Type &that);
-  ::mlir::LLVM::LLVMFixedVectorType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-  unsigned int num_elements(void) const;
-};
-static_assert(sizeof(FixedVectorType) == sizeof(Type));
-
-class MX_EXPORT ScalableVectorType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::LLVM_SCALABLE_VECTOR;
-  }
-
-  static std::optional<ScalableVectorType> from(const ::mx::ir::Type &that);
-  ::mlir::LLVM::LLVMScalableVectorType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //Type element_type(void) const;
-  unsigned int min_num_elements(void) const;
-};
-static_assert(sizeof(ScalableVectorType) == sizeof(Type));
-
-class MX_EXPORT TargetExtType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::LLVM_TARGET_EXT;
-  }
-
-  static std::optional<TargetExtType> from(const ::mx::ir::Type &that);
-  ::mlir::LLVM::LLVMTargetExtType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  bool supports_mem_ops(void) const;
-  std::string_view ext_type_name(void) const;
-  gap::generator<::mx::ir::Type> type_params(void) const &;
-  //::llvm::ArrayRef<unsigned int> int_params(void) const;
-};
-static_assert(sizeof(TargetExtType) == sizeof(Type));
-
-}  // namespace mx::ir::llvm
diff --git a/include/multiplier/IR/LowLevel/Dialect.h b/include/multiplier/IR/LowLevel/Dialect.h
deleted file mode 100644
index e6d6fdd09..000000000
--- a/include/multiplier/IR/LowLevel/Dialect.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "Operation.h"
diff --git a/include/multiplier/IR/LowLevel/Operation.h b/include/multiplier/IR/LowLevel/Operation.h
deleted file mode 100644
index 89be3c95b..000000000
--- a/include/multiplier/IR/LowLevel/Operation.h
+++ /dev/null
@@ -1,380 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Operation.h"
-
-namespace vast::ll {
-class Alloca;
-class ArgAlloca;
-class Br;
-class Concat;
-class CondBr;
-class CondScopeRet;
-class Extract;
-class InitializeVar;
-class InlineScope;
-class Load;
-class FuncOp;
-class StructGEPOp;
-class ReturnOp;
-class Scope;
-class ScopeRecurse;
-class ScopeRet;
-class Store;
-class Subscript;
-class UninitializedVar;
-}  // namespace vast::ll
-namespace mx::ir::ll {
-
-class MX_EXPORT Operation : public ::mx::ir::Operation {
- public:
-  static std::optional<Operation> from(const ::mx::ir::Operation &);
-};
-static_assert(sizeof(Operation) == sizeof(::mx::ir::Operation));
-
-class MX_EXPORT AllocaOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_ALLOCA;
-  }
-
-  static std::optional<AllocaOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AllocaOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::Alloca underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AllocaOp) == sizeof(Operation));
-
-class MX_EXPORT ArgAllocaOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_ARG_ALLOCA;
-  }
-
-  static std::optional<ArgAllocaOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ArgAllocaOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::ArgAlloca underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value fn_arg(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ArgAllocaOp) == sizeof(Operation));
-
-class MX_EXPORT BrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_BR;
-  }
-
-  static std::optional<BrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<BrOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::Br underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> operands(void) const &;
-  //::mlir::Block * dest(void) const;
-};
-static_assert(sizeof(BrOp) == sizeof(Operation));
-
-class MX_EXPORT ConcatOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_CONCAT;
-  }
-
-  static std::optional<ConcatOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ConcatOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::Concat underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> arguments(void) const &;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(ConcatOp) == sizeof(Operation));
-
-class MX_EXPORT CondBrOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_COND_BR;
-  }
-
-  static std::optional<CondBrOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CondBrOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::CondBr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value cond(void) const;
-  gap::generator<::mx::ir::Operand> true_operands(void) const &;
-  gap::generator<::mx::ir::Operand> false_operands(void) const &;
-  //::mlir::Block * true_dest(void) const;
-  //::mlir::Block * false_dest(void) const;
-};
-static_assert(sizeof(CondBrOp) == sizeof(Operation));
-
-class MX_EXPORT CondScopeRetOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_COND_SCOPE_RET;
-  }
-
-  static std::optional<CondScopeRetOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CondScopeRetOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::CondScopeRet underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value cond(void) const;
-  gap::generator<::mx::ir::Operand> dest_operands(void) const &;
-  //::mlir::Block * dest(void) const;
-};
-static_assert(sizeof(CondScopeRetOp) == sizeof(Operation));
-
-class MX_EXPORT ExtractOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_EXTRACT;
-  }
-
-  static std::optional<ExtractOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExtractOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::Extract underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value argument(void) const;
-  ::mx::ir::Value result(void) const;
-  //::mlir::TypedAttr from(void) const;
-  //::mlir::TypedAttr to(void) const;
-  std::size_t size(void) const;
-};
-static_assert(sizeof(ExtractOp) == sizeof(Operation));
-
-class MX_EXPORT InitializeVarOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_INITIALIZE;
-  }
-
-  static std::optional<InitializeVarOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InitializeVarOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::InitializeVar underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value var(void) const;
-  gap::generator<::mx::ir::Operand> elements(void) const &;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(InitializeVarOp) == sizeof(Operation));
-
-class MX_EXPORT InlineScopeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_INLINE_SCOPE;
-  }
-
-  static std::optional<InlineScopeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<InlineScopeOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::InlineScope underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body(void) const;
-};
-static_assert(sizeof(InlineScopeOp) == sizeof(Operation));
-
-class MX_EXPORT LoadOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_LOAD;
-  }
-
-  static std::optional<LoadOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LoadOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::Load underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<ElementTypeInterface> ptr(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(LoadOp) == sizeof(Operation));
-
-class MX_EXPORT FuncOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_FUNC;
-  }
-
-  static std::optional<FuncOp> from(const ::mx::ir::Operation &that);
-  static std::optional<FuncOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::FuncOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::optional<::mx::ir::Region> body(void) const;
-  std::string_view name(void) const;
-  ::mx::ir::Type function_type(void) const;
-  //::std::optional<GlobalLinkageKind> linkage(void) const;
-  std::optional<std::string_view> visibility(void) const;
-  //::std::optional<ArrayAttr> arg_attrs(void) const;
-  //::std::optional<ArrayAttr> res_attrs(void) const;
-  bool is_var_arg(void) const;
-  //::mlir::Region * callable_region(void) const;
-  gap::generator<::mx::ir::Type> callable_results(void) const &;
-  //::mlir::ArrayAttr callable_arg_attrs(void) const;
-  //::mlir::ArrayAttr callable_res_attrs(void) const;
-  gap::generator<::mx::ir::Type> argument_types(void) const &;
-  gap::generator<::mx::ir::Type> result_types(void) const &;
-  bool is_declaration(void) const;
-};
-static_assert(sizeof(FuncOp) == sizeof(Operation));
-
-class MX_EXPORT StructGEPOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_GEP;
-  }
-
-  static std::optional<StructGEPOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StructGEPOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::StructGEPOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value record(void) const;
-  ::mx::ir::Value element(void) const;
-  uint32_t idx(void) const;
-  std::string_view field(void) const;
-};
-static_assert(sizeof(StructGEPOp) == sizeof(Operation));
-
-class MX_EXPORT ReturnOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_RETURN;
-  }
-
-  static std::optional<ReturnOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ReturnOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::ReturnOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> result(void) const &;
-};
-static_assert(sizeof(ReturnOp) == sizeof(Operation));
-
-class MX_EXPORT ScopeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_SCOPE;
-  }
-
-  static std::optional<ScopeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ScopeOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::Scope underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body(void) const;
-  //mlir::Block * start__block(void) const;
-};
-static_assert(sizeof(ScopeOp) == sizeof(Operation));
-
-class MX_EXPORT ScopeRecurseOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_SCOPE_RECURSE;
-  }
-
-  static std::optional<ScopeRecurseOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ScopeRecurseOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::ScopeRecurse underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(ScopeRecurseOp) == sizeof(Operation));
-
-class MX_EXPORT ScopeRetOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_SCOPE_RET;
-  }
-
-  static std::optional<ScopeRetOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ScopeRetOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::ScopeRet underlying_repr(void) const noexcept;
-
-  // Imported methods:
-};
-static_assert(sizeof(ScopeRetOp) == sizeof(Operation));
-
-class MX_EXPORT StoreOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_STORE;
-  }
-
-  static std::optional<StoreOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StoreOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::Store underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<ElementTypeInterface> ptr(void) const;
-};
-static_assert(sizeof(StoreOp) == sizeof(Operation));
-
-class MX_EXPORT SubscriptOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_SUBSCRIPT;
-  }
-
-  static std::optional<SubscriptOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SubscriptOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::Subscript underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value array(void) const;
-  ::mx::ir::Value index(void) const;
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(SubscriptOp) == sizeof(Operation));
-
-class MX_EXPORT UninitializedVarOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::LL_UNINITIALIZED_VAR;
-  }
-
-  static std::optional<UninitializedVarOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UninitializedVarOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::ll::UninitializedVar underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(UninitializedVarOp) == sizeof(Operation));
-
-}  // namespace mx::ir::ll
diff --git a/include/multiplier/IR/MemRef/Dialect.h b/include/multiplier/IR/MemRef/Dialect.h
deleted file mode 100644
index e6d6fdd09..000000000
--- a/include/multiplier/IR/MemRef/Dialect.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "Operation.h"
diff --git a/include/multiplier/IR/MemRef/Operation.h b/include/multiplier/IR/MemRef/Operation.h
deleted file mode 100644
index 7923f8fbc..000000000
--- a/include/multiplier/IR/MemRef/Operation.h
+++ /dev/null
@@ -1,705 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Operation.h"
-
-namespace mlir::memref {
-class AssumeAlignmentOp;
-class AtomicRMWOp;
-class AtomicYieldOp;
-class CopyOp;
-class GenericAtomicRMWOp;
-class LoadOp;
-class AllocOp;
-class AllocaOp;
-class AllocaScopeOp;
-class AllocaScopeReturnOp;
-class CastOp;
-class CollapseShapeOp;
-class DeallocOp;
-class DimOp;
-class DmaStartOp;
-class DmaWaitOp;
-class ExpandShapeOp;
-class ExtractAlignedPointerAsIndexOp;
-class ExtractStridedMetadataOp;
-class GetGlobalOp;
-class GlobalOp;
-class MemorySpaceCastOp;
-class PrefetchOp;
-class RankOp;
-class ReallocOp;
-class ReinterpretCastOp;
-class ReshapeOp;
-class StoreOp;
-class TransposeOp;
-class ViewOp;
-class SubViewOp;
-}  // namespace mlir::memref
-namespace mx::ir::memref {
-
-class MX_EXPORT Operation : public ::mx::ir::Operation {
- public:
-  static std::optional<Operation> from(const ::mx::ir::Operation &);
-};
-static_assert(sizeof(Operation) == sizeof(::mx::ir::Operation));
-
-class MX_EXPORT AssumeAlignmentOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_ASSUME_ALIGNMENT;
-  }
-
-  static std::optional<AssumeAlignmentOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AssumeAlignmentOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::AssumeAlignmentOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> memref(void) const;
-  uint32_t alignment(void) const;
-};
-static_assert(sizeof(AssumeAlignmentOp) == sizeof(Operation));
-
-class MX_EXPORT AtomicRMWOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_ATOMIC_RMW;
-  }
-
-  static std::optional<AtomicRMWOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AtomicRMWOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::AtomicRMWOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<MemRefType> memref(void) const;
-  gap::generator<::mx::ir::Operand> indices(void) const &;
-  ::mx::ir::Value result(void) const;
-  //::mlir::arith::AtomicRMWKind kind(void) const;
-  //MemRefType mem_ref_type(void) const;
-};
-static_assert(sizeof(AtomicRMWOp) == sizeof(Operation));
-
-class MX_EXPORT AtomicYieldOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_ATOMIC_YIELD;
-  }
-
-  static std::optional<AtomicYieldOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AtomicYieldOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::AtomicYieldOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-};
-static_assert(sizeof(AtomicYieldOp) == sizeof(Operation));
-
-class MX_EXPORT CopyOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_COPY;
-  }
-
-  static std::optional<CopyOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CopyOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::CopyOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<BaseMemRefType> source(void) const;
-  //::mlir::TypedValue<BaseMemRefType> target(void) const;
-};
-static_assert(sizeof(CopyOp) == sizeof(Operation));
-
-class MX_EXPORT GenericAtomicRMWOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_GENERIC_ATOMIC_RMW;
-  }
-
-  static std::optional<GenericAtomicRMWOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GenericAtomicRMWOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::GenericAtomicRMWOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> memref(void) const;
-  gap::generator<::mx::ir::Operand> indices(void) const &;
-  ::mx::ir::Value result(void) const;
-  ::mx::ir::Region atomic_body(void) const;
-  //Region & body(void) const;
-  //Value current_value(void) const;
-  //MemRefType mem_ref_type(void) const;
-};
-static_assert(sizeof(GenericAtomicRMWOp) == sizeof(Operation));
-
-class MX_EXPORT LoadOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_LOAD;
-  }
-
-  static std::optional<LoadOp> from(const ::mx::ir::Operation &that);
-  static std::optional<LoadOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::LoadOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> memref(void) const;
-  gap::generator<::mx::ir::Operand> indices(void) const &;
-  ::mx::ir::Value result(void) const;
-  bool nontemporal(void) const;
-  //Value mem_ref(void) const;
-  //MemRefType mem_ref_type(void) const;
-};
-static_assert(sizeof(LoadOp) == sizeof(Operation));
-
-class MX_EXPORT AllocOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_ALLOC;
-  }
-
-  static std::optional<AllocOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AllocOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::AllocOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> dynamic_sizes(void) const &;
-  gap::generator<::mx::ir::Operand> symbol_operands(void) const &;
-  //::mlir::TypedValue<MemRefType> memref(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  //StringRef alignment_attr_str_name(void) const;
-  //MemRefType type(void) const;
-  //SmallVector<OpFoldResult, 6> mixed_sizes(void) const;
-};
-static_assert(sizeof(AllocOp) == sizeof(Operation));
-
-class MX_EXPORT AllocaOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_ALLOCA;
-  }
-
-  static std::optional<AllocaOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AllocaOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::AllocaOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> dynamic_sizes(void) const &;
-  gap::generator<::mx::ir::Operand> symbol_operands(void) const &;
-  //::mlir::TypedValue<MemRefType> memref(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  //::llvm::SmallVector<MemorySlot, 3> promotable_slots(void) const;
-  //::llvm::SmallVector<DestructurableMemorySlot, 1> destructurable_slots(void) const;
-  //StringRef alignment_attr_str_name(void) const;
-  //MemRefType type(void) const;
-  //SmallVector<OpFoldResult, 6> mixed_sizes(void) const;
-};
-static_assert(sizeof(AllocaOp) == sizeof(Operation));
-
-class MX_EXPORT AllocaScopeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_ALLOCA_SCOPE;
-  }
-
-  static std::optional<AllocaScopeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AllocaScopeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::AllocaScopeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Result> results(void) const &;
-  ::mx::ir::Region body_region(void) const;
-};
-static_assert(sizeof(AllocaScopeOp) == sizeof(Operation));
-
-class MX_EXPORT AllocaScopeReturnOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_ALLOCA_SCOPE_RETURN;
-  }
-
-  static std::optional<AllocaScopeReturnOp> from(const ::mx::ir::Operation &that);
-  static std::optional<AllocaScopeReturnOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::AllocaScopeReturnOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> results(void) const &;
-};
-static_assert(sizeof(AllocaScopeReturnOp) == sizeof(Operation));
-
-class MX_EXPORT CastOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_CAST;
-  }
-
-  static std::optional<CastOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CastOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::CastOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<BaseMemRefType> source(void) const;
-  //::mlir::TypedValue<BaseMemRefType> dest(void) const;
-  //Value view_source(void) const;
-};
-static_assert(sizeof(CastOp) == sizeof(Operation));
-
-class MX_EXPORT CollapseShapeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_COLLAPSE_SHAPE;
-  }
-
-  static std::optional<CollapseShapeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<CollapseShapeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::CollapseShapeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> source(void) const;
-  //::mlir::TypedValue<MemRefType> result(void) const;
-  //::mlir::ArrayAttr reassociation(void) const;
-  //SmallVector<AffineMap, 4> reassociation_maps(void) const;
-  //SmallVector<SmallVector<AffineExpr, 2>, 4> reassociation_exprs(void) const;
-  //SmallVector<SmallVector<long long, 2>, 4> reassociation_indices(void) const;
-  //MemRefType src_type(void) const;
-  //MemRefType result_type(void) const;
-  //Value view_source(void) const;
-};
-static_assert(sizeof(CollapseShapeOp) == sizeof(Operation));
-
-class MX_EXPORT DeallocOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_DEALLOC;
-  }
-
-  static std::optional<DeallocOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DeallocOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::DeallocOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<BaseMemRefType> memref(void) const;
-};
-static_assert(sizeof(DeallocOp) == sizeof(Operation));
-
-class MX_EXPORT DimOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_DIM;
-  }
-
-  static std::optional<DimOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DimOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::DimOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value source(void) const;
-  //::mlir::TypedValue<IndexType> index(void) const;
-  //::mlir::TypedValue<IndexType> result(void) const;
-  std::optional<long long> constant_index(void) const;
-  //Value shaped_value(void) const;
-  //OpFoldResult dimension(void) const;
-  //Speculation::Speculatability speculatability(void) const;
-};
-static_assert(sizeof(DimOp) == sizeof(Operation));
-
-class MX_EXPORT DMAStartOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_DMA_START;
-  }
-
-  static std::optional<DMAStartOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DMAStartOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::DmaStartOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  gap::generator<::mx::ir::Operand> operands(void) const &;
-  //Value src_mem_ref(void) const;
-  unsigned int src_mem_ref_rank(void) const;
-  //operand_range src_indices(void) const;
-  //Value dst_mem_ref(void) const;
-  unsigned int dst_mem_ref_rank(void) const;
-  unsigned int src_memory_space(void) const;
-  unsigned int dst_memory_space(void) const;
-  //operand_range dst_indices(void) const;
-  //Value num_elements(void) const;
-  //Value tag_mem_ref(void) const;
-  unsigned int tag_mem_ref_rank(void) const;
-  //operand_range tag_indices(void) const;
-  bool is_dest_memory_space_faster(void) const;
-  bool is_src_memory_space_faster(void) const;
-  unsigned int faster_mem_pos(void) const;
-  bool is_strided(void) const;
-  //Value stride(void) const;
-  //Value num_elements_per_stride(void) const;
-};
-static_assert(sizeof(DMAStartOp) == sizeof(Operation));
-
-class MX_EXPORT DMAWaitOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_DMA_WAIT;
-  }
-
-  static std::optional<DMAWaitOp> from(const ::mx::ir::Operation &that);
-  static std::optional<DMAWaitOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::DmaWaitOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> tag_mem_ref(void) const;
-  gap::generator<::mx::ir::Operand> tag_indices(void) const &;
-  //::mlir::TypedValue<IndexType> num_elements(void) const;
-  unsigned int tag_mem_ref_rank(void) const;
-};
-static_assert(sizeof(DMAWaitOp) == sizeof(Operation));
-
-class MX_EXPORT ExpandShapeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_EXPAND_SHAPE;
-  }
-
-  static std::optional<ExpandShapeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExpandShapeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::ExpandShapeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> source(void) const;
-  //::mlir::TypedValue<MemRefType> result(void) const;
-  //::mlir::ArrayAttr reassociation(void) const;
-  //SmallVector<AffineMap, 4> reassociation_maps(void) const;
-  //SmallVector<SmallVector<AffineExpr, 2>, 4> reassociation_exprs(void) const;
-  //SmallVector<SmallVector<long long, 2>, 4> reassociation_indices(void) const;
-  //MemRefType src_type(void) const;
-  //MemRefType result_type(void) const;
-  //Value view_source(void) const;
-};
-static_assert(sizeof(ExpandShapeOp) == sizeof(Operation));
-
-class MX_EXPORT ExtractAlignedPointerAsIndexOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_EXTRACT_ALIGNED_POINTER_AS_INDEX;
-  }
-
-  static std::optional<ExtractAlignedPointerAsIndexOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExtractAlignedPointerAsIndexOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::ExtractAlignedPointerAsIndexOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> source(void) const;
-  //::mlir::TypedValue<IndexType> aligned_pointer(void) const;
-};
-static_assert(sizeof(ExtractAlignedPointerAsIndexOp) == sizeof(Operation));
-
-class MX_EXPORT ExtractStridedMetadataOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_EXTRACT_STRIDED_METADATA;
-  }
-
-  static std::optional<ExtractStridedMetadataOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ExtractStridedMetadataOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::ExtractStridedMetadataOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> source(void) const;
-  ::mx::ir::Value base_buffer(void) const;
-  //::mlir::TypedValue<IndexType> offset(void) const;
-  gap::generator<::mx::ir::Result> sizes(void) const &;
-  gap::generator<::mx::ir::Result> strides(void) const &;
-  //SmallVector<OpFoldResult, 6> constified_mixed_sizes(void) const;
-  //SmallVector<OpFoldResult, 6> constified_mixed_strides(void) const;
-  //OpFoldResult constified_mixed_offset(void) const;
-  ::mx::ir::Value view_source(void) const;
-};
-static_assert(sizeof(ExtractStridedMetadataOp) == sizeof(Operation));
-
-class MX_EXPORT GetGlobalOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_GET_GLOBAL;
-  }
-
-  static std::optional<GetGlobalOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GetGlobalOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::GetGlobalOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> result(void) const;
-  std::string_view name(void) const;
-};
-static_assert(sizeof(GetGlobalOp) == sizeof(Operation));
-
-class MX_EXPORT GlobalOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_GLOBAL;
-  }
-
-  static std::optional<GlobalOp> from(const ::mx::ir::Operation &that);
-  static std::optional<GlobalOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::GlobalOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view name(void) const;
-  std::optional<std::string_view> visibility(void) const;
-  //::mlir::MemRefType type(void) const;
-  //::std::optional<Attribute> initial_value(void) const;
-  bool constant(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  bool is_external(void) const;
-  bool is_uninitialized(void) const;
-  //ElementsAttr constant_init_value(void) const;
-};
-static_assert(sizeof(GlobalOp) == sizeof(Operation));
-
-class MX_EXPORT MemorySpaceCastOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_MEMORY_SPACE_CAST;
-  }
-
-  static std::optional<MemorySpaceCastOp> from(const ::mx::ir::Operation &that);
-  static std::optional<MemorySpaceCastOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::MemorySpaceCastOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<BaseMemRefType> source(void) const;
-  //::mlir::TypedValue<BaseMemRefType> dest(void) const;
-  //Value view_source(void) const;
-};
-static_assert(sizeof(MemorySpaceCastOp) == sizeof(Operation));
-
-class MX_EXPORT PrefetchOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_PREFETCH;
-  }
-
-  static std::optional<PrefetchOp> from(const ::mx::ir::Operation &that);
-  static std::optional<PrefetchOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::PrefetchOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> memref(void) const;
-  gap::generator<::mx::ir::Operand> indices(void) const &;
-  bool is_write(void) const;
-  uint32_t locality_hint(void) const;
-  bool is_data_cache(void) const;
-  //MemRefType mem_ref_type(void) const;
-  //StringRef locality_hint_attr_str_name(void) const;
-  //StringRef is_write_attr_str_name(void) const;
-  //StringRef is_data_cache_attr_str_name(void) const;
-};
-static_assert(sizeof(PrefetchOp) == sizeof(Operation));
-
-class MX_EXPORT RankOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_RANK;
-  }
-
-  static std::optional<RankOp> from(const ::mx::ir::Operation &that);
-  static std::optional<RankOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::RankOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<BaseMemRefType> memref(void) const;
-};
-static_assert(sizeof(RankOp) == sizeof(Operation));
-
-class MX_EXPORT ReallocOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_REALLOC;
-  }
-
-  static std::optional<ReallocOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ReallocOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::ReallocOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> source(void) const;
-  //::mlir::TypedValue<IndexType> dynamic_result_size(void) const;
-  std::optional<unsigned long long> alignment(void) const;
-  //MemRefType type(void) const;
-};
-static_assert(sizeof(ReallocOp) == sizeof(Operation));
-
-class MX_EXPORT ReinterpretCastOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_REINTERPRET_CAST;
-  }
-
-  static std::optional<ReinterpretCastOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ReinterpretCastOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::ReinterpretCastOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<BaseMemRefType> source(void) const;
-  gap::generator<::mx::ir::Operand> offsets(void) const &;
-  gap::generator<::mx::ir::Operand> sizes(void) const &;
-  gap::generator<::mx::ir::Operand> strides(void) const &;
-  //::mlir::TypedValue<MemRefType> result(void) const;
-  //::llvm::ArrayRef<long long> static_offsets(void) const;
-  //::llvm::ArrayRef<long long> static_sizes(void) const;
-  //::llvm::ArrayRef<long long> static_strides(void) const;
-  gap::generator<::mx::ir::Operand> dynamic_sizes(void) const &;
-  //MemRefType type(void) const;
-  //Value view_source(void) const;
-  unsigned int result_rank(void) const;
-  //std::array<unsigned int, 3> array_attr_max_ranks(void) const;
-  unsigned int offset_size_and_stride_start_operand_index(void) const;
-  //SmallVector<OpFoldResult, 6> constified_mixed_sizes(void) const;
-  //SmallVector<OpFoldResult, 6> constified_mixed_strides(void) const;
-  //OpFoldResult constified_mixed_offset(void) const;
-};
-static_assert(sizeof(ReinterpretCastOp) == sizeof(Operation));
-
-class MX_EXPORT ReshapeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_RESHAPE;
-  }
-
-  static std::optional<ReshapeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ReshapeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::ReshapeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<BaseMemRefType> source(void) const;
-  //::mlir::TypedValue<MemRefType> shape(void) const;
-  //::mlir::TypedValue<BaseMemRefType> result(void) const;
-  //MemRefType type(void) const;
-  //Value view_source(void) const;
-};
-static_assert(sizeof(ReshapeOp) == sizeof(Operation));
-
-class MX_EXPORT StoreOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_STORE;
-  }
-
-  static std::optional<StoreOp> from(const ::mx::ir::Operation &that);
-  static std::optional<StoreOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::StoreOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value value(void) const;
-  //::mlir::TypedValue<MemRefType> memref(void) const;
-  gap::generator<::mx::ir::Operand> indices(void) const &;
-  bool nontemporal(void) const;
-  //Value value_to_store(void) const;
-  //Value mem_ref(void) const;
-  //MemRefType mem_ref_type(void) const;
-};
-static_assert(sizeof(StoreOp) == sizeof(Operation));
-
-class MX_EXPORT TransposeOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_TRANSPOSE;
-  }
-
-  static std::optional<TransposeOp> from(const ::mx::ir::Operation &that);
-  static std::optional<TransposeOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::TransposeOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> in(void) const;
-  //::mlir::AffineMap permutation(void) const;
-  //StringRef permutation_attr_str_name(void) const;
-};
-static_assert(sizeof(TransposeOp) == sizeof(Operation));
-
-class MX_EXPORT ViewOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_VIEW;
-  }
-
-  static std::optional<ViewOp> from(const ::mx::ir::Operation &that);
-  static std::optional<ViewOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::ViewOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> source(void) const;
-  //::mlir::TypedValue<IndexType> byte_shift(void) const;
-  gap::generator<::mx::ir::Operand> sizes(void) const &;
-  ::mx::ir::Value view_source(void) const;
-  //MemRefType type(void) const;
-  //operand_range dynamic_sizes(void) const;
-};
-static_assert(sizeof(ViewOp) == sizeof(Operation));
-
-class MX_EXPORT SubViewOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::MEMREF_SUBVIEW;
-  }
-
-  static std::optional<SubViewOp> from(const ::mx::ir::Operation &that);
-  static std::optional<SubViewOp> producing(const ::mx::ir::Value &val);
-
-  ::mlir::memref::SubViewOp underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //::mlir::TypedValue<MemRefType> source(void) const;
-  gap::generator<::mx::ir::Operand> offsets(void) const &;
-  gap::generator<::mx::ir::Operand> sizes(void) const &;
-  gap::generator<::mx::ir::Operand> strides(void) const &;
-  //::mlir::TypedValue<MemRefType> result(void) const;
-  //::llvm::ArrayRef<long long> static_offsets(void) const;
-  //::llvm::ArrayRef<long long> static_sizes(void) const;
-  //::llvm::ArrayRef<long long> static_strides(void) const;
-  ::mx::ir::Value view_source(void) const;
-  gap::generator<::mx::ir::Operand> dynamic_sizes(void) const &;
-  //MemRefType source_type(void) const;
-  //MemRefType type(void) const;
-  //std::array<unsigned int, 3> array_attr_max_ranks(void) const;
-  unsigned int offset_size_and_stride_start_operand_index(void) const;
-  //llvm::SmallBitVector dropped_dims(void) const;
-};
-static_assert(sizeof(SubViewOp) == sizeof(Operation));
-
-}  // namespace mx::ir::memref
diff --git a/include/multiplier/IR/Meta/Attribute.h b/include/multiplier/IR/Meta/Attribute.h
deleted file mode 100644
index 2ed76f637..000000000
--- a/include/multiplier/IR/Meta/Attribute.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Attribute.h"
-
-namespace vast::meta {
-class IdentifierAttr;
-}  // namespace vast::meta
-namespace mx::ir::meta {
-
-class MX_EXPORT Attribute : public ::mx::ir::Attribute {
- public:
-  static std::optional<Attribute> from(const ::mx::ir::Attribute &);
-};
-static_assert(sizeof(Attribute) == sizeof(::mx::ir::Attribute));
-
-class MX_EXPORT IdentifierAttr final : public Attribute {
- public:
-  inline static constexpr AttributeKind static_kind(void) {
-    return AttributeKind::META_IDENTIFIER;
-  }
-
-  static std::optional<IdentifierAttr> from(const ::mx::ir::Attribute &that);
-
-  ::vast::meta::IdentifierAttr underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  //identifier_t value(void) const;
-};
-static_assert(sizeof(IdentifierAttr) == sizeof(Attribute));
-
-}  // namespace mx::ir::meta
diff --git a/include/multiplier/IR/Meta/Dialect.h b/include/multiplier/IR/Meta/Dialect.h
deleted file mode 100644
index e793c4f74..000000000
--- a/include/multiplier/IR/Meta/Dialect.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "Attribute.h"
diff --git a/include/multiplier/IR/Operation.h b/include/multiplier/IR/Operation.h
deleted file mode 100644
index 8da85b76c..000000000
--- a/include/multiplier/IR/Operation.h
+++ /dev/null
@@ -1,288 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#pragma once
-
-#include <cstdint>
-#include <gap/coro/generator.hpp>
-#include <optional>
-#include <memory>
-#include <string_view>
-
-#include "OperationKind.h"
-#include "Value.h"
-
-#include "../Types.h"
-
-namespace mlir {
-class Operation;
-class OpOperand;
-namespace detail {
-class OpResultImpl;
-}  // namespace detail
-}  // namespace mlir
-namespace mx {
-class Decl;
-class Fragment;
-class Index;
-class Stmt;
-
-enum class DeclKind : unsigned char;
-enum class StmtKind : unsigned char;
-
-namespace ir {
-class Attribute;
-class Block;
-class Argument;
-class Label;
-class Region;
-class Result;
-class Operand;
-class SourceIRImpl;
-class Symbol;
-class Value;
-
-// An operation is like an 'instruction', but can contain arbitrary
-// complexity in the form or one or more regions, each of which can
-// embed their own control-flow graphs of blocks containing operations.
-class MX_EXPORT Operation {
- private:
-  friend class Attribute;
-  friend class Block;
-  friend class Label;
-  friend class Operand;
-  friend class Region;
-  friend class Result;
-  friend class SourceIRImpl;
-  friend class Symbol;
-  friend class Value;
-
-  friend class ::mx::Decl;
-  friend class ::mx::Fragment;
-  friend class ::mx::Index;
-  friend class ::mx::Stmt;
-
-  Operation(void) = delete;
-
- protected:
-  std::shared_ptr<const SourceIRImpl> module_;
-  mlir::Operation *op_;
-  OperationKind kind_;
-
- public:
-  Operation(std::shared_ptr<const SourceIRImpl> module,
-            mlir::Operation *opaque,
-            OperationKind kind);
-
-  inline Operation(std::shared_ptr<const SourceIRImpl> module,
-                   mlir::Operation *opaque)
-      : Operation(std::move(module), opaque, classify(opaque)) {}
-
-  inline Operation(std::shared_ptr<const SourceIRImpl> module, void *opaque)
-      : Operation(std::move(module),
-                  reinterpret_cast<mlir::Operation *>(opaque)) {}
-
-  inline mlir::Operation *underlying_operation(void) const noexcept {
-    return op_;
-  }
-
-  // Classify an MLIR operation, by raw pointer or by operation name.
-  static OperationKind classify(mlir::Operation *);
-  static OperationKind classify(std::string_view);
-
-  // The name of this operation.
-  std::string_view kind_name(void) const noexcept;
-
-  // Return the ID of this operation.
-  EntityId id(void) const noexcept;
-
-  // Kind of this operation. If the kind is from a dialect that isn't recognized
-  // by multiplier, then `OperationKind::UNKNOWN` is returned.
-  inline OperationKind kind(void) const noexcept {
-    return kind_;
-  }
-
-  // Results (a kind of value) are always produced by operations.
-  inline static Operation producing(const Result &val);
-
-  // Some values are produced by operations. 
-  static std::optional<Operation> producing(const Value &val);
-
-  // Regions and blocks are always contained inside of an operation.
-  static Operation containing(const Region &);
-  static Operation containing(const Block &);
-
-  static std::optional<Operation> first_from(const ::mx::Decl &that);
-  static std::optional<Operation> first_from(const ::mx::Decl &that, OperationKind);
-  static gap::generator<Operation> all_from(const ::mx::Decl &that);
-
-  static std::optional<Operation> first_from(const ::mx::Stmt &that);
-  static std::optional<Operation> first_from(const ::mx::Stmt &that, OperationKind);
-  static gap::generator<Operation> all_from(const ::mx::Stmt &that);
-
-  // Operations can have zero or more operands.
-  unsigned num_operands(void) const noexcept;
-  std::optional<Operand> nth_operand(unsigned) const noexcept;
-  gap::generator<Operand> operands(void) const & noexcept;
-
-  // Operations can produce zero or more results.
-  unsigned num_results(void) const noexcept;
-  std::optional<Result> nth_result(unsigned) const noexcept;
-  gap::generator<Result> results(void) const & noexcept;
-
-  // Operations can have zero or more nested regions. Regions allow one to
-  // model sequential control-flow and concurrent data-flow graphs of
-  // computation.
-  unsigned num_regions(void) const noexcept;
-  std::optional<Region> nth_region(unsigned) const noexcept;
-  gap::generator<Region> regions(void) const & noexcept;
-
-  // If an operation has only one region, the return that region.
-  std::optional<Region> only_region(void) const noexcept;
-
-  // If an operation has only one region, then visit those blocks.
-  gap::generator<Block> only_region_blocks(void) const & noexcept;
-
-  // An operation can have zero or more uses. A use of an operation is a use of
-  // one of the result values of the operations.
-  gap::generator<Operand> uses(void) const & noexcept;
-
-  // Return the previous and next operations in the current `Block`.
-  std::optional<Operation> previous(void) const noexcept;
-  std::optional<Operation> next(void) const noexcept;
-
-  // Returns `true` whether or not this operation is a terminator.
-  bool is_terminator(void) const noexcept;
-
-  // Return the symbol defined by this operation, if any.
-  std::optional<Symbol> defined_symbol(void) const noexcept;
-
-  // Return the operation defining a symbol.
-  static Operation defining(const Symbol &symbol);
-
-  bool operator==(const Operation &that) const noexcept;
-  bool operator!=(const Operation &that) const noexcept = default;
-
-  // Dump this operation.
-  void dump(void) const;
-};
-
-// A value produced as a result of an operation.
-class Result final : public Value {
- private:
-  friend class Value;
-  friend class Operation;
-
- public:
-
-  inline static constexpr ValueKind static_kind(void) noexcept {
-    return ValueKind::OPERATION_RESULT;
-  }
-
-  inline Result(std::shared_ptr<const SourceIRImpl> module,
-                void *res)
-      : Value(std::move(module),
-              reinterpret_cast<mlir::detail::OpResultImpl *>(res)) {}
-
-  // If an operation has only one result, then return it.
-  static std::optional<Result> of(const Operation &);
-
-  // Try to down-cast a `Value` to a `Result`.
-  static std::optional<Result> from(const Value &);
-
-  // Return the operation producing this result.
-  Operation operation(void) const noexcept;
-
-  // Index of this result in its operation's result list.
-  unsigned index(void) const noexcept;
-
-  bool operator==(const Result &that) const noexcept;
-  bool operator!=(const Result &that) const noexcept = default;
-};
-
-static_assert(sizeof(Result) == sizeof(Value));
-
-inline Operation Operation::producing(const Result &res) {
-  return res.operation();
-}
-
-// A use of a value by a specific operation.
-class MX_EXPORT Operand {
- private:
-  friend class Block;
-  friend class Label;
-  friend class Operation;
-  friend class Value;
-
-  std::shared_ptr<const SourceIRImpl> module_;
-  mlir::OpOperand *op_;
-
- public:
-
-  inline Operand(std::shared_ptr<const SourceIRImpl> module, void *op)
-      : module_(std::move(module)),
-        op_(reinterpret_cast<mlir::OpOperand *>(op)) {}
-
-  inline mlir::OpOperand *underlying_operand(void) const noexcept {
-    return op_;
-  }
-
-  // The operation containing this operand.
-  Operation operation(void) const noexcept;
-
-  // The index of this operand within its owner operation's operand list.
-  unsigned index(void) const noexcept;
-
-  // Value associated with this operand. This could be a block argument, or
-  // the result of another operation.
-  Value value(void) const noexcept;
-
-  bool operator==(const Operand &that) const noexcept;
-  bool operator!=(const Operand &that) const noexcept = default;
-};
-
-// API for symbols defined by operations.
-class MX_EXPORT Symbol {
- private:
-  friend class Block;
-  friend class Label;
-  friend class Operation;
-  friend class Value;
-
-  std::shared_ptr<const SourceIRImpl> module_;
-  mlir::Operation *op_;
-  OperationKind kind_;
-
- public:
-
-  inline Symbol(std::shared_ptr<const SourceIRImpl> module,
-                mlir::Operation *opaque,
-                OperationKind kind)
-      : module_(std::move(module)),
-        op_(opaque),
-        kind_(kind) {}
-
-  inline mlir::Operation *underlying_operation(void) const noexcept {
-    return op_;
-  }
-
-  // If an operation defines a symbol then return it.
-  static std::optional<Symbol> from(const Operation &);
-
-  // The operation defining this symbol.
-  Operation operation(void) const noexcept;
-
-  // Name of this symbol.
-  std::string_view name(void) const noexcept;
-
-  // References to this symbol.
-  gap::generator<Operation> references(void) const & noexcept;
-
-  bool operator==(const Symbol &that) const noexcept;
-  bool operator!=(const Symbol &that) const noexcept = default;
-};
-
-}  // namespace ir
-}  // namespace mx
diff --git a/include/multiplier/IR/OperationKind.h b/include/multiplier/IR/OperationKind.h
deleted file mode 100644
index 7f21b8c76..000000000
--- a/include/multiplier/IR/OperationKind.h
+++ /dev/null
@@ -1,499 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Compiler.h"
-
-namespace mx {
-namespace ir {
-
-enum class OperationKind : unsigned {
-  UNKNOWN,
-  BUILTIN_MODULE,  // builtin.module
-  BUILTIN_UNREALIZED_CONVERSION_CAST,  // builtin.unrealized_conversion_cast
-  LLVM_ASHR,  // llvm.ashr
-  LLVM_ADD,  // llvm.add
-  LLVM_ADDRSPACECAST,  // llvm.addrspacecast
-  LLVM_MLIR_ADDRESSOF,  // llvm.mlir.addressof
-  LLVM_ALLOCA,  // llvm.alloca
-  LLVM_AND,  // llvm.and
-  LLVM_CMPXCHG,  // llvm.cmpxchg
-  LLVM_ATOMICRMW,  // llvm.atomicrmw
-  LLVM_BITCAST,  // llvm.bitcast
-  LLVM_BR,  // llvm.br
-  LLVM_CALL_INTRINSIC,  // llvm.call_intrinsic
-  LLVM_CALL,  // llvm.call
-  LLVM_COMDAT,  // llvm.comdat
-  LLVM_COMDAT_SELECTOR,  // llvm.comdat_selector
-  LLVM_COND_BR,  // llvm.cond_br
-  LLVM_MLIR_CONSTANT,  // llvm.mlir.constant
-  LLVM_EXTRACTELEMENT,  // llvm.extractelement
-  LLVM_EXTRACTVALUE,  // llvm.extractvalue
-  LLVM_FADD,  // llvm.fadd
-  LLVM_FCMP,  // llvm.fcmp
-  LLVM_FDIV,  // llvm.fdiv
-  LLVM_FMUL,  // llvm.fmul
-  LLVM_FNEG,  // llvm.fneg
-  LLVM_FPEXT,  // llvm.fpext
-  LLVM_FPTOSI,  // llvm.fptosi
-  LLVM_FPTOUI,  // llvm.fptoui
-  LLVM_FPTRUNC,  // llvm.fptrunc
-  LLVM_FREM,  // llvm.frem
-  LLVM_FSUB,  // llvm.fsub
-  LLVM_FENCE,  // llvm.fence
-  LLVM_FREEZE,  // llvm.freeze
-  LLVM_GETELEMENTPTR,  // llvm.getelementptr
-  LLVM_MLIR_GLOBAL_CTORS,  // llvm.mlir.global_ctors
-  LLVM_MLIR_GLOBAL_DTORS,  // llvm.mlir.global_dtors
-  LLVM_MLIR_GLOBAL,  // llvm.mlir.global
-  LLVM_ICMP,  // llvm.icmp
-  LLVM_INLINE_ASM,  // llvm.inline_asm
-  LLVM_INSERTELEMENT,  // llvm.insertelement
-  LLVM_INSERTVALUE,  // llvm.insertvalue
-  LLVM_INTTOPTR,  // llvm.inttoptr
-  LLVM_INVOKE,  // llvm.invoke
-  LLVM_FUNC,  // llvm.func
-  LLVM_LSHR,  // llvm.lshr
-  LLVM_LANDINGPAD,  // llvm.landingpad
-  LLVM_LINKER_OPTIONS,  // llvm.linker_options
-  LLVM_LOAD,  // llvm.load
-  LLVM_MUL,  // llvm.mul
-  LLVM_MLIR_NONE,  // llvm.mlir.none
-  LLVM_OR,  // llvm.or
-  LLVM_MLIR_POISON,  // llvm.mlir.poison
-  LLVM_PTRTOINT,  // llvm.ptrtoint
-  LLVM_RESUME,  // llvm.resume
-  LLVM_RETURN,  // llvm.return
-  LLVM_SDIV,  // llvm.sdiv
-  LLVM_SEXT,  // llvm.sext
-  LLVM_SITOFP,  // llvm.sitofp
-  LLVM_SREM,  // llvm.srem
-  LLVM_SELECT,  // llvm.select
-  LLVM_SHL,  // llvm.shl
-  LLVM_SHUFFLEVECTOR,  // llvm.shufflevector
-  LLVM_STORE,  // llvm.store
-  LLVM_SUB,  // llvm.sub
-  LLVM_SWITCH,  // llvm.switch
-  LLVM_TRUNC,  // llvm.trunc
-  LLVM_UDIV,  // llvm.udiv
-  LLVM_UITOFP,  // llvm.uitofp
-  LLVM_UREM,  // llvm.urem
-  LLVM_MLIR_UNDEF,  // llvm.mlir.undef
-  LLVM_UNREACHABLE,  // llvm.unreachable
-  LLVM_XOR,  // llvm.xor
-  LLVM_ZEXT,  // llvm.zext
-  LLVM_MLIR_ZERO,  // llvm.mlir.zero
-  LLVM_INTR_ABS,  // llvm.intr.abs
-  LLVM_INTR_ANNOTATION,  // llvm.intr.annotation
-  LLVM_INTR_ASSUME,  // llvm.intr.assume
-  LLVM_INTR_BITREVERSE,  // llvm.intr.bitreverse
-  LLVM_INTR_BSWAP,  // llvm.intr.bswap
-  LLVM_INTR_COPYSIGN,  // llvm.intr.copysign
-  LLVM_INTR_CORO_ALIGN,  // llvm.intr.coro.align
-  LLVM_INTR_CORO_BEGIN,  // llvm.intr.coro.begin
-  LLVM_INTR_CORO_END,  // llvm.intr.coro.end
-  LLVM_INTR_CORO_FREE,  // llvm.intr.coro.free
-  LLVM_INTR_CORO_ID,  // llvm.intr.coro.id
-  LLVM_INTR_CORO_PROMISE,  // llvm.intr.coro.promise
-  LLVM_INTR_CORO_RESUME,  // llvm.intr.coro.resume
-  LLVM_INTR_CORO_SAVE,  // llvm.intr.coro.save
-  LLVM_INTR_CORO_SIZE,  // llvm.intr.coro.size
-  LLVM_INTR_CORO_SUSPEND,  // llvm.intr.coro.suspend
-  LLVM_INTR_COS,  // llvm.intr.cos
-  LLVM_INTR_CTLZ,  // llvm.intr.ctlz
-  LLVM_INTR_CTTZ,  // llvm.intr.cttz
-  LLVM_INTR_CTPOP,  // llvm.intr.ctpop
-  LLVM_INTR_DBG_DECLARE,  // llvm.intr.dbg.declare
-  LLVM_INTR_DBG_LABEL,  // llvm.intr.dbg.label
-  LLVM_INTR_DBG_VALUE,  // llvm.intr.dbg.value
-  LLVM_INTR_DEBUGTRAP,  // llvm.intr.debugtrap
-  LLVM_INTR_EH_TYPEID_FOR,  // llvm.intr.eh.typeid.for
-  LLVM_INTR_EXP2,  // llvm.intr.exp2
-  LLVM_INTR_EXP,  // llvm.intr.exp
-  LLVM_INTR_EXPECT,  // llvm.intr.expect
-  LLVM_INTR_EXPECT_WITH_PROBABILITY,  // llvm.intr.expect.with.probability
-  LLVM_INTR_FABS,  // llvm.intr.fabs
-  LLVM_INTR_CEIL,  // llvm.intr.ceil
-  LLVM_INTR_FLOOR,  // llvm.intr.floor
-  LLVM_INTR_FMA,  // llvm.intr.fma
-  LLVM_INTR_FMULADD,  // llvm.intr.fmuladd
-  LLVM_INTR_TRUNC,  // llvm.intr.trunc
-  LLVM_INTR_FSHL,  // llvm.intr.fshl
-  LLVM_INTR_FSHR,  // llvm.intr.fshr
-  LLVM_INTR_GET_ACTIVE_LANE_MASK,  // llvm.intr.get.active.lane.mask
-  LLVM_INTR_INVARIANT_END,  // llvm.intr.invariant.end
-  LLVM_INTR_INVARIANT_START,  // llvm.intr.invariant.start
-  LLVM_INTR_IS_CONSTANT,  // llvm.intr.is.constant
-  LLVM_INTR_IS_FPCLASS,  // llvm.intr.is.fpclass
-  LLVM_INTR_LIFETIME_END,  // llvm.intr.lifetime.end
-  LLVM_INTR_LIFETIME_START,  // llvm.intr.lifetime.start
-  LLVM_INTR_LLRINT,  // llvm.intr.llrint
-  LLVM_INTR_LLROUND,  // llvm.intr.llround
-  LLVM_INTR_LOG10,  // llvm.intr.log10
-  LLVM_INTR_LOG2,  // llvm.intr.log2
-  LLVM_INTR_LOG,  // llvm.intr.log
-  LLVM_INTR_LRINT,  // llvm.intr.lrint
-  LLVM_INTR_LROUND,  // llvm.intr.lround
-  LLVM_INTR_MASKED_LOAD,  // llvm.intr.masked.load
-  LLVM_INTR_MASKED_STORE,  // llvm.intr.masked.store
-  LLVM_INTR_MATRIX_COLUMN_MAJOR_LOAD,  // llvm.intr.matrix.column.major.load
-  LLVM_INTR_MATRIX_COLUMN_MAJOR_STORE,  // llvm.intr.matrix.column.major.store
-  LLVM_INTR_MATRIX_MULTIPLY,  // llvm.intr.matrix.multiply
-  LLVM_INTR_MATRIX_TRANSPOSE,  // llvm.intr.matrix.transpose
-  LLVM_INTR_MAXNUM,  // llvm.intr.maxnum
-  LLVM_INTR_MAXIMUM,  // llvm.intr.maximum
-  LLVM_INTR_MEMCPY_INLINE,  // llvm.intr.memcpy.inline
-  LLVM_INTR_MEMCPY,  // llvm.intr.memcpy
-  LLVM_INTR_MEMMOVE,  // llvm.intr.memmove
-  LLVM_INTR_MEMSET,  // llvm.intr.memset
-  LLVM_INTR_MINNUM,  // llvm.intr.minnum
-  LLVM_INTR_MINIMUM,  // llvm.intr.minimum
-  LLVM_INTR_NEARBYINT,  // llvm.intr.nearbyint
-  LLVM_INTR_EXPERIMENTAL_NOALIAS_SCOPE_DECL,  // llvm.intr.experimental.noalias.scope.decl
-  LLVM_INTR_POWI,  // llvm.intr.powi
-  LLVM_INTR_POW,  // llvm.intr.pow
-  LLVM_INTR_PREFETCH,  // llvm.intr.prefetch
-  LLVM_INTR_PTR_ANNOTATION,  // llvm.intr.ptr.annotation
-  LLVM_INTR_RINT,  // llvm.intr.rint
-  LLVM_INTR_ROUNDEVEN,  // llvm.intr.roundeven
-  LLVM_INTR_ROUND,  // llvm.intr.round
-  LLVM_INTR_SADD_SAT,  // llvm.intr.sadd.sat
-  LLVM_INTR_SADD_WITH_OVERFLOW,  // llvm.intr.sadd.with.overflow
-  LLVM_INTR_SMAX,  // llvm.intr.smax
-  LLVM_INTR_SMIN,  // llvm.intr.smin
-  LLVM_INTR_SMUL_WITH_OVERFLOW,  // llvm.intr.smul.with.overflow
-  LLVM_INTR_SSA_COPY,  // llvm.intr.ssa.copy
-  LLVM_INTR_SSHL_SAT,  // llvm.intr.sshl.sat
-  LLVM_INTR_SSUB_SAT,  // llvm.intr.ssub.sat
-  LLVM_INTR_SSUB_WITH_OVERFLOW,  // llvm.intr.ssub.with.overflow
-  LLVM_INTR_SIN,  // llvm.intr.sin
-  LLVM_INTR_SQRT,  // llvm.intr.sqrt
-  LLVM_INTR_STACKRESTORE,  // llvm.intr.stackrestore
-  LLVM_INTR_STACKSAVE,  // llvm.intr.stacksave
-  LLVM_INTR_EXPERIMENTAL_STEPVECTOR,  // llvm.intr.experimental.stepvector
-  LLVM_INTR_THREADLOCAL_ADDRESS,  // llvm.intr.threadlocal.address
-  LLVM_INTR_TRAP,  // llvm.intr.trap
-  LLVM_INTR_UADD_SAT,  // llvm.intr.uadd.sat
-  LLVM_INTR_UADD_WITH_OVERFLOW,  // llvm.intr.uadd.with.overflow
-  LLVM_INTR_UBSANTRAP,  // llvm.intr.ubsantrap
-  LLVM_INTR_UMAX,  // llvm.intr.umax
-  LLVM_INTR_UMIN,  // llvm.intr.umin
-  LLVM_INTR_UMUL_WITH_OVERFLOW,  // llvm.intr.umul.with.overflow
-  LLVM_INTR_USHL_SAT,  // llvm.intr.ushl.sat
-  LLVM_INTR_USUB_SAT,  // llvm.intr.usub.sat
-  LLVM_INTR_USUB_WITH_OVERFLOW,  // llvm.intr.usub.with.overflow
-  LLVM_INTR_VP_ASHR,  // llvm.intr.vp.ashr
-  LLVM_INTR_VP_ADD,  // llvm.intr.vp.add
-  LLVM_INTR_VP_AND,  // llvm.intr.vp.and
-  LLVM_INTR_VP_FADD,  // llvm.intr.vp.fadd
-  LLVM_INTR_VP_FDIV,  // llvm.intr.vp.fdiv
-  LLVM_INTR_VP_FMULADD,  // llvm.intr.vp.fmuladd
-  LLVM_INTR_VP_FMUL,  // llvm.intr.vp.fmul
-  LLVM_INTR_VP_FNEG,  // llvm.intr.vp.fneg
-  LLVM_INTR_VP_FPEXT,  // llvm.intr.vp.fpext
-  LLVM_INTR_VP_FPTOSI,  // llvm.intr.vp.fptosi
-  LLVM_INTR_VP_FPTOUI,  // llvm.intr.vp.fptoui
-  LLVM_INTR_VP_FPTRUNC,  // llvm.intr.vp.fptrunc
-  LLVM_INTR_VP_FREM,  // llvm.intr.vp.frem
-  LLVM_INTR_VP_FSUB,  // llvm.intr.vp.fsub
-  LLVM_INTR_VP_FMA,  // llvm.intr.vp.fma
-  LLVM_INTR_VP_INTTOPTR,  // llvm.intr.vp.inttoptr
-  LLVM_INTR_VP_LSHR,  // llvm.intr.vp.lshr
-  LLVM_INTR_VP_LOAD,  // llvm.intr.vp.load
-  LLVM_INTR_VP_MERGE,  // llvm.intr.vp.merge
-  LLVM_INTR_VP_MUL,  // llvm.intr.vp.mul
-  LLVM_INTR_VP_OR,  // llvm.intr.vp.or
-  LLVM_INTR_VP_PTRTOINT,  // llvm.intr.vp.ptrtoint
-  LLVM_INTR_VP_REDUCE_ADD,  // llvm.intr.vp.reduce.add
-  LLVM_INTR_VP_REDUCE_AND,  // llvm.intr.vp.reduce.and
-  LLVM_INTR_VP_REDUCE_FADD,  // llvm.intr.vp.reduce.fadd
-  LLVM_INTR_VP_REDUCE_FMAX,  // llvm.intr.vp.reduce.fmax
-  LLVM_INTR_VP_REDUCE_FMIN,  // llvm.intr.vp.reduce.fmin
-  LLVM_INTR_VP_REDUCE_FMUL,  // llvm.intr.vp.reduce.fmul
-  LLVM_INTR_VP_REDUCE_MUL,  // llvm.intr.vp.reduce.mul
-  LLVM_INTR_VP_REDUCE_OR,  // llvm.intr.vp.reduce.or
-  LLVM_INTR_VP_REDUCE_SMAX,  // llvm.intr.vp.reduce.smax
-  LLVM_INTR_VP_REDUCE_SMIN,  // llvm.intr.vp.reduce.smin
-  LLVM_INTR_VP_REDUCE_UMAX,  // llvm.intr.vp.reduce.umax
-  LLVM_INTR_VP_REDUCE_UMIN,  // llvm.intr.vp.reduce.umin
-  LLVM_INTR_VP_REDUCE_XOR,  // llvm.intr.vp.reduce.xor
-  LLVM_INTR_VP_SDIV,  // llvm.intr.vp.sdiv
-  LLVM_INTR_VP_SEXT,  // llvm.intr.vp.sext
-  LLVM_INTR_VP_SITOFP,  // llvm.intr.vp.sitofp
-  LLVM_INTR_VP_SREM,  // llvm.intr.vp.srem
-  LLVM_INTR_VP_SELECT,  // llvm.intr.vp.select
-  LLVM_INTR_VP_SHL,  // llvm.intr.vp.shl
-  LLVM_INTR_VP_STORE,  // llvm.intr.vp.store
-  LLVM_INTR_EXPERIMENTAL_VP_STRIDED_LOAD,  // llvm.intr.experimental.vp.strided.load
-  LLVM_INTR_EXPERIMENTAL_VP_STRIDED_STORE,  // llvm.intr.experimental.vp.strided.store
-  LLVM_INTR_VP_SUB,  // llvm.intr.vp.sub
-  LLVM_INTR_VP_TRUNC,  // llvm.intr.vp.trunc
-  LLVM_INTR_VP_UDIV,  // llvm.intr.vp.udiv
-  LLVM_INTR_VP_UITOFP,  // llvm.intr.vp.uitofp
-  LLVM_INTR_VP_UREM,  // llvm.intr.vp.urem
-  LLVM_INTR_VP_XOR,  // llvm.intr.vp.xor
-  LLVM_INTR_VP_ZEXT,  // llvm.intr.vp.zext
-  LLVM_INTR_VACOPY,  // llvm.intr.vacopy
-  LLVM_INTR_VAEND,  // llvm.intr.vaend
-  LLVM_INTR_VASTART,  // llvm.intr.vastart
-  LLVM_INTR_VAR_ANNOTATION,  // llvm.intr.var.annotation
-  LLVM_INTR_MASKED_COMPRESSSTORE,  // llvm.intr.masked.compressstore
-  LLVM_INTR_MASKED_EXPANDLOAD,  // llvm.intr.masked.expandload
-  LLVM_INTR_MASKED_GATHER,  // llvm.intr.masked.gather
-  LLVM_INTR_MASKED_SCATTER,  // llvm.intr.masked.scatter
-  LLVM_INTR_VECTOR_EXTRACT,  // llvm.intr.vector.extract
-  LLVM_INTR_VECTOR_INSERT,  // llvm.intr.vector.insert
-  LLVM_INTR_VECTOR_REDUCE_ADD,  // llvm.intr.vector.reduce.add
-  LLVM_INTR_VECTOR_REDUCE_AND,  // llvm.intr.vector.reduce.and
-  LLVM_INTR_VECTOR_REDUCE_FADD,  // llvm.intr.vector.reduce.fadd
-  LLVM_INTR_VECTOR_REDUCE_FMAX,  // llvm.intr.vector.reduce.fmax
-  LLVM_INTR_VECTOR_REDUCE_FMAXIMUM,  // llvm.intr.vector.reduce.fmaximum
-  LLVM_INTR_VECTOR_REDUCE_FMIN,  // llvm.intr.vector.reduce.fmin
-  LLVM_INTR_VECTOR_REDUCE_FMINIMUM,  // llvm.intr.vector.reduce.fminimum
-  LLVM_INTR_VECTOR_REDUCE_FMUL,  // llvm.intr.vector.reduce.fmul
-  LLVM_INTR_VECTOR_REDUCE_MUL,  // llvm.intr.vector.reduce.mul
-  LLVM_INTR_VECTOR_REDUCE_OR,  // llvm.intr.vector.reduce.or
-  LLVM_INTR_VECTOR_REDUCE_SMAX,  // llvm.intr.vector.reduce.smax
-  LLVM_INTR_VECTOR_REDUCE_SMIN,  // llvm.intr.vector.reduce.smin
-  LLVM_INTR_VECTOR_REDUCE_UMAX,  // llvm.intr.vector.reduce.umax
-  LLVM_INTR_VECTOR_REDUCE_UMIN,  // llvm.intr.vector.reduce.umin
-  LLVM_INTR_VECTOR_REDUCE_XOR,  // llvm.intr.vector.reduce.xor
-  LLVM_INTR_VSCALE,  // llvm.intr.vscale
-  MEMREF_ASSUME_ALIGNMENT,  // memref.assume_alignment
-  MEMREF_ATOMIC_RMW,  // memref.atomic_rmw
-  MEMREF_ATOMIC_YIELD,  // memref.atomic_yield
-  MEMREF_COPY,  // memref.copy
-  MEMREF_GENERIC_ATOMIC_RMW,  // memref.generic_atomic_rmw
-  MEMREF_LOAD,  // memref.load
-  MEMREF_ALLOC,  // memref.alloc
-  MEMREF_ALLOCA,  // memref.alloca
-  MEMREF_ALLOCA_SCOPE,  // memref.alloca_scope
-  MEMREF_ALLOCA_SCOPE_RETURN,  // memref.alloca_scope.return
-  MEMREF_CAST,  // memref.cast
-  MEMREF_COLLAPSE_SHAPE,  // memref.collapse_shape
-  MEMREF_DEALLOC,  // memref.dealloc
-  MEMREF_DIM,  // memref.dim
-  MEMREF_DMA_START,  // memref.dma_start
-  MEMREF_DMA_WAIT,  // memref.dma_wait
-  MEMREF_EXPAND_SHAPE,  // memref.expand_shape
-  MEMREF_EXTRACT_ALIGNED_POINTER_AS_INDEX,  // memref.extract_aligned_pointer_as_index
-  MEMREF_EXTRACT_STRIDED_METADATA,  // memref.extract_strided_metadata
-  MEMREF_GET_GLOBAL,  // memref.get_global
-  MEMREF_GLOBAL,  // memref.global
-  MEMREF_MEMORY_SPACE_CAST,  // memref.memory_space_cast
-  MEMREF_PREFETCH,  // memref.prefetch
-  MEMREF_RANK,  // memref.rank
-  MEMREF_REALLOC,  // memref.realloc
-  MEMREF_REINTERPRET_CAST,  // memref.reinterpret_cast
-  MEMREF_RESHAPE,  // memref.reshape
-  MEMREF_STORE,  // memref.store
-  MEMREF_TRANSPOSE,  // memref.transpose
-  MEMREF_VIEW,  // memref.view
-  MEMREF_SUBVIEW,  // memref.subview
-  ABI_CALL_ARGS,  // abi.call_args
-  ABI_CALL_EXEC,  // abi.call_exec
-  ABI_CALL,  // abi.call
-  ABI_CALL_RETS,  // abi.call_rets
-  ABI_DIRECT,  // abi.direct
-  ABI_EPILOGUE,  // abi.epilogue
-  ABI_FUNC,  // abi.func
-  ABI_INDIRECT,  // abi.indirect
-  ABI_PROLOGUE,  // abi.prologue
-  ABI_RET_DIRECT,  // abi.ret_direct
-  ABI_YIELD,  // abi.yield
-  LL_ALLOCA,  // ll.alloca
-  LL_ARG_ALLOCA,  // ll.arg_alloca
-  LL_BR,  // ll.br
-  LL_CONCAT,  // ll.concat
-  LL_COND_BR,  // ll.cond_br
-  LL_COND_SCOPE_RET,  // ll.cond_scope_ret
-  LL_EXTRACT,  // ll.extract
-  LL_INITIALIZE,  // ll.initialize
-  LL_INLINE_SCOPE,  // ll.inline_scope
-  LL_LOAD,  // ll.load
-  LL_FUNC,  // ll.func
-  LL_GEP,  // ll.gep
-  LL_RETURN,  // ll.return
-  LL_SCOPE,  // ll.scope
-  LL_SCOPE_RECURSE,  // ll.scope_recurse
-  LL_SCOPE_RET,  // ll.scope_ret
-  LL_STORE,  // ll.store
-  LL_SUBSCRIPT,  // ll.subscript
-  LL_UNINITIALIZED_VAR,  // ll.uninitialized_var
-  HL_ACCESS,  // hl.access
-  HL_ASSIGN_FADD,  // hl.assign.fadd
-  HL_FADD,  // hl.fadd
-  HL_ASSIGN_ADD,  // hl.assign.add
-  HL_ADD,  // hl.add
-  HL_LABELADDR,  // hl.labeladdr
-  HL_ADDRESSOF,  // hl.addressof
-  HL_ALIGNOF_EXPR,  // hl.alignof.expr
-  HL_ALIGNOF_TYPE,  // hl.alignof.type
-  HL_ASM,  // hl.asm
-  HL_ASSIGN,  // hl.assign
-  HL_ATTRIBUTED_STMT,  // hl.attributed_stmt
-  HL_ASSIGN_BIN_ASHR,  // hl.assign.bin.ashr
-  HL_BIN_ASHR,  // hl.bin.ashr
-  HL_ASSIGN_BIN_AND,  // hl.assign.bin.and
-  HL_BIN_AND,  // hl.bin.and
-  HL_BIN_COMMA,  // hl.bin.comma
-  HL_BIN_LAND,  // hl.bin.land
-  HL_BIN_LOR,  // hl.bin.lor
-  HL_ASSIGN_BIN_LSHR,  // hl.assign.bin.lshr
-  HL_BIN_LSHR,  // hl.bin.lshr
-  HL_ASSIGN_BIN_OR,  // hl.assign.bin.or
-  HL_BIN_OR,  // hl.bin.or
-  HL_ASSIGN_BIN_SHL,  // hl.assign.bin.shl
-  HL_BIN_SHL,  // hl.bin.shl
-  HL_ASSIGN_BIN_XOR,  // hl.assign.bin.xor
-  HL_BIN_XOR,  // hl.bin.xor
-  HL_BINARY_COND,  // hl.binary_cond
-  HL_BREAK,  // hl.break
-  HL_BUILTIN_BITCAST,  // hl.builtin_bitcast
-  HL_BUILTIN_TYPES_COMPATIBLE_P_TYPE,  // hl.builtin_types_compatible_p.type
-  HL_CSTYLE_CAST,  // hl.cstyle_cast
-  HL_CALL,  // hl.call
-  HL_CASE,  // hl.case
-  HL_CHOOSE_EXPR,  // hl.choose_expr
-  HL_CLASS,  // hl.class
-  HL_CMP,  // hl.cmp
-  HL_COMPOUND_LITERAL,  // hl.compound_literal
-  HL_COND,  // hl.cond
-  HL_COND_YIELD,  // hl.cond.yield
-  HL_CONST,  // hl.const
-  HL_CONTINUE,  // hl.continue
-  HL_BASE,  // hl.base
-  HL_CXXSTRUCT,  // hl.cxxstruct
-  HL_REF,  // hl.ref
-  HL_DEFAULT,  // hl.default
-  HL_DEREF,  // hl.deref
-  HL_ASSIGN_FDIV,  // hl.assign.fdiv
-  HL_FDIV,  // hl.fdiv
-  HL_ASSIGN_SDIV,  // hl.assign.sdiv
-  HL_SDIV,  // hl.sdiv
-  HL_ASSIGN_UDIV,  // hl.assign.udiv
-  HL_UDIV,  // hl.udiv
-  HL_DO,  // hl.do
-  HL_EMPTY_DECL,  // hl.empty.decl
-  HL_ENUM_CONST,  // hl.enum.const
-  HL_ENUM,  // hl.enum
-  HL_ENUMREF,  // hl.enumref
-  HL_EXPR,  // hl.expr
-  HL_GNU_EXTENSION,  // hl.gnu.extension
-  HL_FCMP,  // hl.fcmp
-  HL_FIELD,  // hl.field
-  HL_FILE_SCOPE_ASM,  // hl.file_scope_asm
-  HL_FOR,  // hl.for
-  HL_FUNC,  // hl.func
-  HL_FUNCREF,  // hl.funcref
-  HL_GENERIC_ASOC,  // hl.generic_asoc
-  HL_GENERIC_EXPR,  // hl.generic_expr
-  HL_GLOBREF,  // hl.globref
-  HL_GOTO,  // hl.goto
-  HL_IF,  // hl.if
-  HL_IMAG,  // hl.imag
-  HL_IMPLICIT_CAST,  // hl.implicit_cast
-  HL_INDIRECT_CALL,  // hl.indirect_call
-  HL_INDIRECT_GOTO,  // hl.indirect_goto
-  HL_INITLIST,  // hl.initlist
-  HL_CONST_INIT,  // hl.const.init
-  HL_LNOT,  // hl.lnot
-  HL_LABEL_DECL,  // hl.label.decl
-  HL_LABEL,  // hl.label
-  HL_MINUS,  // hl.minus
-  HL_ASSIGN_FMUL,  // hl.assign.fmul
-  HL_FMUL,  // hl.fmul
-  HL_ASSIGN_MUL,  // hl.assign.mul
-  HL_MUL,  // hl.mul
-  HL_NOT,  // hl.not
-  HL_NULL,  // hl.null
-  HL_OFFSETOF_EXPR,  // hl.offsetof.expr
-  HL_OPAQUE_EXPR,  // hl.opaque_expr
-  HL_PLUS,  // hl.plus
-  HL_POST_DEC,  // hl.post.dec
-  HL_POST_INC,  // hl.post.inc
-  HL_PRE_DEC,  // hl.pre.dec
-  HL_PRE_INC,  // hl.pre.inc
-  HL_PREDEFINED_EXPR,  // hl.predefined.expr
-  HL_PREFERRED_ALIGNOF_EXPR,  // hl.preferred_alignof.expr
-  HL_PREFERRED_ALIGNOF_TYPE,  // hl.preferred_alignof.type
-  HL_REAL,  // hl.real
-  HL_MEMBER,  // hl.member
-  HL_ASSIGN_FREM,  // hl.assign.frem
-  HL_FREM,  // hl.frem
-  HL_ASSIGN_SREM,  // hl.assign.srem
-  HL_SREM,  // hl.srem
-  HL_ASSIGN_UREM,  // hl.assign.urem
-  HL_UREM,  // hl.urem
-  HL_RETURN,  // hl.return
-  HL_SIZEOF_EXPR,  // hl.sizeof.expr
-  HL_SIZEOF_TYPE,  // hl.sizeof.type
-  HL_STATIC_ASSERT,  // hl.static_assert
-  HL_STMT_EXPR,  // hl.stmt.expr
-  HL_STRUCT,  // hl.struct
-  HL_ASSIGN_FSUB,  // hl.assign.fsub
-  HL_FSUB,  // hl.fsub
-  HL_ASSIGN_SUB,  // hl.assign.sub
-  HL_SUB,  // hl.sub
-  HL_SUBSCRIPT,  // hl.subscript
-  HL_SWITCH,  // hl.switch
-  HL_THIS,  // hl.this
-  HL_TRANSLATION_UNIT,  // hl.translation_unit
-  HL_ALIAS,  // hl.alias
-  HL_TYPE,  // hl.type
-  HL_TYPEDEF,  // hl.typedef
-  HL_TYPEOF_EXPR,  // hl.typeof.expr
-  HL_TYPE_YIELD,  // hl.type.yield
-  HL_UNION,  // hl.union
-  HL_UNREACHABLE,  // hl.unreachable
-  HL_VA_ARG_EXPR,  // hl.va_arg_expr
-  HL_VALUE_YIELD,  // hl.value.yield
-  HL_VAR,  // hl.var
-  HL_WHILE,  // hl.while
-  CORE_BIN_LAND,  // core.bin.land
-  CORE_BIN_LOR,  // core.bin.lor
-  CORE_IMPLICIT_RETURN,  // core.implicit.return
-  CORE_LAZY_OP,  // core.lazy.op
-  CORE_MODULE,  // core.module
-  CORE_SCOPE,  // core.scope
-  CORE_SELECT,  // core.select
-  UNSUP_DECL,  // unsup.decl
-  UNSUP_STMT,  // unsup.stmt
-};
-
-}  // namespace ir
-
-inline static const char *EnumerationName(ir::OperationKind) {
-  return "OperationKind";
-}
-
-inline static constexpr unsigned NumEnumerators(ir::OperationKind) {
-  return 451;
-}
-
-MX_EXPORT const char *EnumeratorName(ir::OperationKind);
-
-MX_EXPORT bool IsBuiltinOperationKind(ir::OperationKind);
-
-MX_EXPORT bool IsLLVMIROperationKind(ir::OperationKind);
-
-MX_EXPORT bool IsMemRefOperationKind(ir::OperationKind);
-
-MX_EXPORT bool IsABIOperationKind(ir::OperationKind);
-
-MX_EXPORT bool IsLowLevelOperationKind(ir::OperationKind);
-
-MX_EXPORT bool IsHighLevelOperationKind(ir::OperationKind);
-
-MX_EXPORT bool IsCoreOperationKind(ir::OperationKind);
-
-MX_EXPORT bool IsMetaOperationKind(ir::OperationKind);
-
-MX_EXPORT bool IsUnsupportedOperationKind(ir::OperationKind);
-
-}  // namespace mx
diff --git a/include/multiplier/IR/Region.h b/include/multiplier/IR/Region.h
deleted file mode 100644
index 547d96e9c..000000000
--- a/include/multiplier/IR/Region.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#pragma once
-
-#include <gap/coro/generator.hpp>
-#include <memory>
-#include <optional>
-
-#include "../Compiler.h"
-
-namespace mlir {
-class Region;
-}  // namespace mlir
-namespace mx::ir {
-
-class Block;
-class Argument;
-class Operation;
-class SourceIRImpl;
-
-enum BasicBlockOrder : int {
-  PRE_ORDER,
-  POST_ORDER
-};
-
-inline static const char *EnumerationName(BasicBlockOrder) {
-  return "BasicBlockOrder";
-}
-
-MX_EXPORT const char *EnumeratorName(BasicBlockOrder);
-
-inline static constexpr unsigned NumEnumerators(BasicBlockOrder) {
-  return 2;
-}
-
-// A region is owned by an operation (not all operations own regions)
-// and contain one or more blocks.
-class MX_EXPORT Region final {
- private:
-  friend class Operation;
-  friend class Block;
-  friend class Argument;
-
-  std::shared_ptr<const SourceIRImpl> module_;
-  mlir::Region *region_;
-
- public:
-  Region(std::shared_ptr<const SourceIRImpl> module,
-         mlir::Region *region);
-
-  inline Region(std::shared_ptr<const SourceIRImpl> module,
-                mlir::Region &region)
-      : Region(std::move(module), &region) {}
-
-  inline mlir::Region *underlying_region(void) const noexcept {
-    return region_;
-  }
-
-  static Region containing(const Block &);
-
-  // In general, all operations are contained inside a region, except the
-  // module operation.
-  static std::optional<Region> containing(const Operation &);
-
-  // Regions have one or more basic blocks.
-  unsigned num_blocks(void) const noexcept;
-  std::optional<Block> nth_block(unsigned) const noexcept;
-  gap::generator<Block> blocks(void) const & noexcept;
-  gap::generator<Block> reverse_blocks(void) const & noexcept;
-
-  // All regions have a designated entry block. The arguments to that entry
-  // block are also the arguments to the region.
-  Block entry_block(void) const noexcept;
-  unsigned num_entry_block_arguments(void) const noexcept;
-  std::optional<Argument> nth_entry_block_argument(unsigned) const noexcept;
-  gap::generator<Argument> entry_block_arguments(void) const & noexcept;
-
-  bool operator==(const Region &that) const noexcept;
-  bool operator!=(const Region &that) const noexcept;
-};
-
-}  // namespace mx::ir
diff --git a/include/multiplier/IR/Type.h b/include/multiplier/IR/Type.h
deleted file mode 100644
index 84ba6e2af..000000000
--- a/include/multiplier/IR/Type.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#pragma once
-
-#include <gap/coro/generator.hpp>
-#include <memory>
-#include <optional>
-#include <string_view>
-
-#include "TypeKind.h"
-#include "../Compiler.h"
-
-namespace mlir {
-class MLIRContext;
-class TypeStorage;
-}  // namespace mlir
-namespace mx::ir {
-
-class Operation;
-class Block;
-class Argument;
-class SourceIRImpl;
-class Type;
-
-// The type of some operation / value.
-class MX_EXPORT Type {
- private:
-  friend class Operation;
-  friend class Block;
-  friend class Argument;
-  friend class Value;
- 
- protected:
-  mlir::MLIRContext *context_;
-  mlir::TypeStorage *type_;
-  TypeKind kind_;
-
- public:
-  Type(mlir::MLIRContext *context, const mlir::TypeStorage *type)
-      : context_(std::move(context)),
-        type_(const_cast<mlir::TypeStorage *>(type)),
-        kind_(classify(type_)) {}
-
-  static TypeKind classify(mlir::TypeStorage *type);
-
-  inline TypeKind kind(void) const noexcept {
-    return kind_;
-  }
-
-  inline mlir::TypeStorage *underlying_type(void) const noexcept {
-    return type_;
-  }
-
-  inline bool operator==(const Type &that) const noexcept {
-    return type_ == that.type_;
-  }
-
-  inline bool operator!=(const Type &that) const noexcept {
-    return type_ != that.type_;
-  }
-};
-
-}  // namespace mx::ir
diff --git a/include/multiplier/IR/TypeKind.h b/include/multiplier/IR/TypeKind.h
deleted file mode 100644
index e77ab2ea5..000000000
--- a/include/multiplier/IR/TypeKind.h
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Compiler.h"
-
-namespace mx {
-namespace ir {
-
-enum class TypeKind : unsigned {
-  UNKNOWN,
-  BUILTIN_SHAPED,
-  BUILTIN_FLOAT,
-  BUILTIN_COMPLEX,
-  BUILTIN_FLOAT8_E5_M2,
-  BUILTIN_FLOAT8_E4_M3_FN,
-  BUILTIN_FLOAT8_E5_M2_FNUZ,
-  BUILTIN_FLOAT8_E4_M3_FNUZ,
-  BUILTIN_FLOAT8_E4_M3_B11_FNUZ,
-  BUILTIN_B_FLOAT16,
-  BUILTIN_FLOAT16,
-  BUILTIN_FLOAT_TF32,
-  BUILTIN_FLOAT32,
-  BUILTIN_FLOAT64,
-  BUILTIN_FLOAT80,
-  BUILTIN_FLOAT128,
-  BUILTIN_FUNCTION,
-  BUILTIN_INDEX,
-  BUILTIN_INTEGER,
-  BUILTIN_MEM_REF,
-  BUILTIN_NONE,
-  BUILTIN_OPAQUE,
-  BUILTIN_RANKED_TENSOR,
-  BUILTIN_TUPLE,
-  BUILTIN_UNRANKED_MEM_REF,
-  BUILTIN_UNRANKED_TENSOR,
-  BUILTIN_VECTOR,
-  LLVM_ARRAY,
-  LLVM_FUNCTION,
-  LLVM_POINTER,
-  LLVM_FIXED_VECTOR,
-  LLVM_SCALABLE_VECTOR,
-  LLVM_TARGET_EXT,
-  HL_RECORD,
-  HL_ENUM,
-  HL_TYPEDEF,
-  HL_ELABORATED,
-  HL_LABEL,
-  HL_PAREN,
-  HL_L_VALUE,
-  HL_R_VALUE,
-  HL_VOID,
-  HL_BOOL,
-  HL_CHAR,
-  HL_SHORT,
-  HL_INT,
-  HL_LONG,
-  HL_LONG_LONG,
-  HL_INT128,
-  HL_HALF,
-  HL_B_FLOAT16,
-  HL_FLOAT,
-  HL_DOUBLE,
-  HL_LONG_DOUBLE,
-  HL_FLOAT128,
-  HL_COMPLEX,
-  HL_POINTER,
-  HL_ARRAY,
-  HL_VECTOR,
-  HL_DECAYED,
-  HL_ATTRIBUTED,
-  HL_ADJUSTED,
-  HL_REFERENCE,
-  HL_TYPE_OF_EXPR,
-  HL_TYPE_OF_TYPE,
-  HL_AUTO,
-  HL_ATOMIC,
-  CORE_FUNCTION,
-  UNSUP_UNSUPPORTED,
-};
-
-}  // namespace ir
-
-inline static const char *EnumerationName(ir::TypeKind) {
-  return "TypeKind";
-}
-
-inline static constexpr unsigned NumEnumerators(ir::TypeKind) {
-  return 68;
-}
-
-MX_EXPORT const char *EnumeratorName(ir::TypeKind);
-
-MX_EXPORT bool IsBuiltinTypeKind(ir::TypeKind);
-
-MX_EXPORT bool IsLLVMIRTypeKind(ir::TypeKind);
-
-MX_EXPORT bool IsMemRefTypeKind(ir::TypeKind);
-
-MX_EXPORT bool IsABITypeKind(ir::TypeKind);
-
-MX_EXPORT bool IsLowLevelTypeKind(ir::TypeKind);
-
-MX_EXPORT bool IsHighLevelTypeKind(ir::TypeKind);
-
-MX_EXPORT bool IsCoreTypeKind(ir::TypeKind);
-
-MX_EXPORT bool IsMetaTypeKind(ir::TypeKind);
-
-MX_EXPORT bool IsUnsupportedTypeKind(ir::TypeKind);
-
-}  // namespace mx
diff --git a/include/multiplier/IR/Unsupported/Dialect.h b/include/multiplier/IR/Unsupported/Dialect.h
deleted file mode 100644
index 5dff509bc..000000000
--- a/include/multiplier/IR/Unsupported/Dialect.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "Type.h"
-#include "Operation.h"
diff --git a/include/multiplier/IR/Unsupported/Operation.h b/include/multiplier/IR/Unsupported/Operation.h
deleted file mode 100644
index a856c5d77..000000000
--- a/include/multiplier/IR/Unsupported/Operation.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Operation.h"
-
-namespace vast::unsup {
-class UnsupportedDecl;
-class UnsupportedStmt;
-}  // namespace vast::unsup
-namespace mx::ir::unsup {
-
-class MX_EXPORT Operation : public ::mx::ir::Operation {
- public:
-  static std::optional<Operation> from(const ::mx::ir::Operation &);
-};
-static_assert(sizeof(Operation) == sizeof(::mx::ir::Operation));
-
-class MX_EXPORT UnsupportedDeclOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::UNSUP_DECL;
-  }
-
-  static std::optional<UnsupportedDeclOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UnsupportedDeclOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::unsup::UnsupportedDecl underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Region body(void) const;
-  std::string_view name(void) const;
-};
-static_assert(sizeof(UnsupportedDeclOp) == sizeof(Operation));
-
-class MX_EXPORT UnsupportedStmtOp final : public Operation {
- public:
-  inline static constexpr OperationKind static_kind(void) {
-    return OperationKind::UNSUP_STMT;
-  }
-
-  static std::optional<UnsupportedStmtOp> from(const ::mx::ir::Operation &that);
-  static std::optional<UnsupportedStmtOp> producing(const ::mx::ir::Value &val);
-
-  ::vast::unsup::UnsupportedStmt underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  ::mx::ir::Value result(void) const;
-  gap::generator<::mx::ir::Region> children(void) const &;
-  std::string_view name(void) const;
-};
-static_assert(sizeof(UnsupportedStmtOp) == sizeof(Operation));
-
-}  // namespace mx::ir::unsup
diff --git a/include/multiplier/IR/Unsupported/Type.h b/include/multiplier/IR/Unsupported/Type.h
deleted file mode 100644
index 1c01aa4ad..000000000
--- a/include/multiplier/IR/Unsupported/Type.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#include "../Type.h"
-
-namespace vast::unsup {
-class UnsupportedType;
-}  // namespace vast::unsup
-namespace mx::ir::unsup {
-
-class MX_EXPORT Type : public ::mx::ir::Type {
- public:
-  static std::optional<Type> from(const ::mx::ir::Type &);
-};
-static_assert(sizeof(Type) == sizeof(::mx::ir::Type));
-
-class MX_EXPORT UnsupportedType final : public Type {
- public:
-  inline static constexpr TypeKind static_kind(void) {
-    return TypeKind::UNSUP_UNSUPPORTED;
-  }
-
-  static std::optional<UnsupportedType> from(const ::mx::ir::Type &that);
-  ::vast::unsup::UnsupportedType underlying_repr(void) const noexcept;
-
-  // Imported methods:
-  std::string_view origin_name(void) const;
-};
-static_assert(sizeof(UnsupportedType) == sizeof(Type));
-
-}  // namespace mx::ir::unsup
diff --git a/include/multiplier/IR/Value.h b/include/multiplier/IR/Value.h
deleted file mode 100644
index b7122a8a7..000000000
--- a/include/multiplier/IR/Value.h
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#pragma once
-
-#include <gap/coro/generator.hpp>
-#include <memory>
-#include <optional>
-#include <type_traits>
-#include <utility>
-
-#include "../Compiler.h"
-
-namespace mlir {
-class Value;
-namespace detail {
-class BlockArgumentImpl;
-class OpResultImpl;
-class ValueImpl;
-}  // namespace detail
-}  // namespace mlir
-namespace mx::ir {
-
-class Operation;
-class Block;
-class Argument;
-class Operand;
-class Result;
-class SourceIRImpl;
-class Type;
-
-enum ValueKind : unsigned char {
-  OPERATION_RESULT,
-  BLOCK_ARGUMENT
-};
-
-inline static const char *EnumerationName(ValueKind) {
-  return "ValueKind";
-}
-
-MX_EXPORT const char *EnumeratorName(ValueKind);
-
-inline static constexpr unsigned NumEnumerators(ValueKind) {
-  return 2;
-}
-
-// The result of an operation, or an argument to a block. Values can
-// have an arbitrary number of users.
-class MX_EXPORT Value {
- protected:
-  friend class Operand;
-  friend class Operation;
-  friend class Block;
-  friend class Argument;
-  friend class Result;
-
-  std::shared_ptr<const SourceIRImpl> module_;
-
-  union Impl {
-    void *opaque;
-    mlir::detail::ValueImpl *value;
-    mlir::detail::BlockArgumentImpl *arg;
-    mlir::detail::OpResultImpl *result;
-
-    inline Impl(void *opaque_)
-        : opaque(opaque_) {}
-
-  } impl_;
-
- public:
-
-  Value(std::shared_ptr<const SourceIRImpl> module, void *value);
-
-  ValueKind kind(void) const noexcept;
-
-  Type type(void) const noexcept;
-
-  // Generate the uses of this value.
-  gap::generator<Operand> uses(void) const & noexcept;
-
-  inline void *underlying_value(void) const noexcept {
-    return impl_.opaque;
-  }
-
-  bool operator==(const Value &that) const noexcept;
-  bool operator!=(const Value &that) const noexcept = default;
-};
-
-// A value with a specific type.
-template <typename T>
-class MX_EXPORT TypedValue : public Value {
- public:
-  static_assert(std::is_base_of_v<Type, T>);
-
-  inline T type(void) const noexcept {
-    return reinterpret_cast<const T &>(Value::type());
-  }
-};
-
-}  // namespace mx::ir
diff --git a/include/multiplier/Index.h b/include/multiplier/Index.h
index 7f613f9b3..6be991a4d 100644
--- a/include/multiplier/Index.h
+++ b/include/multiplier/Index.h
@@ -26,16 +26,11 @@
 #include "Frontend/Macro.h"
 #include "Frontend/TokenKind.h"
 #include "Frontend/TokenCategory.h"
-#include "IR/Operation.h"
 #include "Fragment.h"
-#include "IR/Operation.h"
 #include "Iterator.h"
 #include "Reference.h"
 
 namespace mx {
-namespace ir {
-class Operation;
-}  // namespace ir
 
 class CachingEntityProvider;
 class Compilation;
@@ -70,7 +65,6 @@ using VariantEntity = std::variant<
                                             MX_DECLARE_ENTITY_VARIANT,
                                             MX_DECLARE_ENTITY_VARIANT,
                                             MX_DECLARE_ENTITY_VARIANT,
-                                            MX_DECLARE_ENTITY_VARIANT,
                                             MX_DECLARE_ENTITY_VARIANT)>;
 #undef MX_DECLARE_ENTITY_VARIANT
 
@@ -105,7 +99,6 @@ class MX_EXPORT Index final {
                               MX_FRIEND,
                               MX_FRIEND,
                               MX_FRIEND,
-                              MX_FRIEND,
                               MX_FRIEND)
 #undef MX_FRIEND
 
@@ -149,8 +142,6 @@ class MX_EXPORT Index final {
   static std::optional<Index> containing(const Token &entity);
   static std::optional<Index> containing(const VariantEntity &entity);
 
-  static Index containing(const ir::Operation &entity);
-
   // Return the status of the index.
   IndexStatus status(bool block=false) const;
 
@@ -176,7 +167,7 @@ class MX_EXPORT Index final {
   MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_GETTER, MX_IGNORE_ENTITY_CATEGORY,
                               MX_DECLARE_GETTER, MX_DECLARE_GETTER,
                               MX_DECLARE_GETTER, MX_DECLARE_GETTER,
-                              MX_DECLARE_GETTER, MX_DECLARE_GETTER)
+                              MX_DECLARE_GETTER)
 #undef MX_DECLARE_GETTER
 
   template <typename T>
@@ -248,7 +239,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_REFERENCE_AS,
                             MX_REFERENCE_AS,
                             MX_REFERENCE_AS,
                             MX_REFERENCE_AS,
-                            MX_REFERENCE_AS,
                             MX_REFERENCE_AS)
 #undef MX_REFERENCE_AS
   } else {
diff --git a/include/multiplier/Iterator.h b/include/multiplier/Iterator.h
index 68713c7ca..ca873021c 100644
--- a/include/multiplier/Iterator.h
+++ b/include/multiplier/Iterator.h
@@ -11,9 +11,6 @@
 #include "Types.h"
 
 namespace mx {
-namespace ir {
-class Operation;
-}  // namespace ir
 
 class FragmentImpl;
 class TokenContextReader;
@@ -28,8 +25,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_FORWARD_DECLARE_ENTITY,
                             MX_FORWARD_DECLARE_ENTITY,
                             MX_FORWARD_DECLARE_ENTITY,
                             MX_FORWARD_DECLARE_ENTITY,
-                            MX_FORWARD_DECLARE_ENTITY,
-                            MX_IGNORE_ENTITY_CATEGORY)
+                            MX_FORWARD_DECLARE_ENTITY)
 #undef MX_FORWARD_DECLARE_ENTITY
 
 class IteratorEnd {};
diff --git a/include/multiplier/Reference.h b/include/multiplier/Reference.h
index 7750a42cc..c965d2535 100644
--- a/include/multiplier/Reference.h
+++ b/include/multiplier/Reference.h
@@ -223,7 +223,6 @@ class MX_EXPORT Reference {
                               MX_FRIEND,
                               MX_FRIEND,
                               MX_FRIEND,
-                              MX_FRIEND,
                               MX_FRIEND)
 #undef MX_FRIEND
 
@@ -295,7 +294,6 @@ class MX_EXPORT Reference {
                               MX_DECLARE_REF_GETTER,
                               MX_DECLARE_REF_GETTER,
                               MX_DECLARE_REF_GETTER,
-                              MX_DECLARE_REF_GETTER,
                               MX_DECLARE_REF_GETTER)
 #undef MX_DECLARE_REF_GETTER
 
diff --git a/include/multiplier/Types.h b/include/multiplier/Types.h
index e8ac556ae..327c3b98d 100644
--- a/include/multiplier/Types.h
+++ b/include/multiplier/Types.h
@@ -18,10 +18,6 @@
 #include "Compiler.h"
 
 namespace mx {
-namespace ir {
-class Operation;
-enum class OperationKind : unsigned;
-}  // namespace ir
 
 class Token;
 
@@ -33,7 +29,7 @@ enum class TokenKind : unsigned short;
 enum class TypeKind : unsigned char;
 
 #define MX_IGNORE_ENTITY_CATEGORY(ns_path, type_name, lower_name, enum_name, category)
-#define MX_FOR_EACH_ENTITY_CATEGORY(file_, token_, type_, frag_, frag_offset_, pseudo_, tu_, ir_) \
+#define MX_FOR_EACH_ENTITY_CATEGORY(file_, token_, type_, frag_, frag_offset_, pseudo_, tu_) \
     frag_(::mx::, Fragment, fragment, FRAGMENT, 1) \
     frag_offset_(::mx::, Decl, declaration, DECLARATION, 2) \
     frag_offset_(::mx::, Stmt, statement, STATEMENT, 3) \
@@ -47,8 +43,7 @@ enum class TypeKind : unsigned char;
     pseudo_(::mx::, CXXBaseSpecifier, cxx_base_specifier, CXX_BASE_SPECIFIER, 11) \
     pseudo_(::mx::, Designator, designator, DESIGNATOR, 12) \
     pseudo_(::mx::, CXXCtorInitializer, cxx_ctor_initializer, CXX_CTOR_INITIALIZER, 13) \
-    tu_(::mx::, Compilation, compilation, COMPILATION, 14) \
-    ir_(::mx::ir::, Operation, operation, OPERATION, 15)
+    tu_(::mx::, Compilation, compilation, COMPILATION, 14)
 
 #define MX_DECLARE_ENTITY_CLASS(ns_path, type, lower, enum_, val) \
     class type;\
@@ -60,8 +55,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_CLASS,
                             MX_DECLARE_ENTITY_CLASS,
                             MX_DECLARE_ENTITY_CLASS,
                             MX_DECLARE_ENTITY_CLASS,
-                            MX_DECLARE_ENTITY_CLASS,
-                            MX_IGNORE_ENTITY_CATEGORY)
+                            MX_DECLARE_ENTITY_CLASS)
 #undef MX_DECLARE_ENTITY_CLASS
 
 using NotAnEntity = std::monostate;
@@ -75,7 +69,6 @@ enum class EntityCategory : int {
                               MX_DECLARE_ENTITY_CATEGORY_ENUM,
                               MX_DECLARE_ENTITY_CATEGORY_ENUM,
                               MX_DECLARE_ENTITY_CATEGORY_ENUM,
-                              MX_DECLARE_ENTITY_CATEGORY_ENUM,
                               MX_DECLARE_ENTITY_CATEGORY_ENUM)
 #undef MX_DECLARE_ENTITY_CATEGORY_ENUM
 };
@@ -114,7 +107,6 @@ inline static constexpr unsigned NumEnumerators(EntityCategory) {
                                        MX_COUNT_ENTITY_CATEGORIES,
                                        MX_COUNT_ENTITY_CATEGORIES,
                                        MX_COUNT_ENTITY_CATEGORIES,
-                                       MX_COUNT_ENTITY_CATEGORIES,
                                        MX_COUNT_ENTITY_CATEGORIES);
 #undef MX_COUNT_ENTITY_CATEGORIES
 }
@@ -346,7 +338,7 @@ struct MX_EXPORT CXXCtorInitializerId final {
 };
 
 // Translation units represent a compilation. From a translation unit we can
-// get the compile command, the MLIR, etc.
+// get the compile command, etc.
 struct MX_EXPORT CompilationId {
 
   // The ID of the compilation/translation unit.
@@ -359,27 +351,6 @@ struct MX_EXPORT CompilationId {
   auto operator<=>(const CompilationId &) const noexcept = default;
 };
 
-// Identifies a serialized version of a `clang::Attr` or `pasta::Attr` inside
-// of a `Fragment`.
-struct MX_EXPORT OperationId final {
-  RawEntityId compilation_id;
-  ir::OperationKind kind;
-  EntityOffset offset;
-  EntityOffset level;
-
-  inline explicit OperationId(RawEntityId compilation_id_,
-                              ir::OperationKind kind_,
-                              EntityOffset offset_,
-                              EntityOffset level_)
-      : compilation_id(compilation_id_),
-        kind(kind_),
-        offset(offset_),
-        level(level_) {}
-
-  bool operator==(const OperationId &) const noexcept = default;
-  auto operator<=>(const OperationId &) const noexcept = default;
-};
-
 // Identifies a serialized fragment.
 struct MX_EXPORT FragmentId final {
   RawEntityId fragment_id;
@@ -439,7 +410,6 @@ using VariantId = std::variant<
                                 MX_ENTITY_ID_VARIANT,
                                 MX_ENTITY_ID_VARIANT,
                                 MX_ENTITY_ID_VARIANT,
-                                MX_ENTITY_ID_VARIANT,
                                 MX_ENTITY_ID_VARIANT)
     ParsedTokenId, MacroTokenId, FileTokenId, TypeTokenId>;
 #undef MX_ENTITY_ID_VARIANT
@@ -478,7 +448,6 @@ class MX_EXPORT EntityId final {
   /* implicit */ EntityId(DesignatorId id);
   /* implicit */ EntityId(CXXCtorInitializerId id);
   /* implicit */ EntityId(CompilationId id);
-  /* implicit */ EntityId(OperationId id);
 
   template <typename T>
   /* implicit */ inline EntityId(SpecificEntityId<T>);
@@ -647,7 +616,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_MAP_ENTITY_TYPE,
                             MX_MAP_ENTITY_TYPE,
                             MX_MAP_ENTITY_TYPE,
                             MX_MAP_ENTITY_TYPE,
-                            MX_MAP_ENTITY_TYPE,
                             MX_MAP_ENTITY_TYPE)
 #undef MX_MAP_ENTITY_TYPE
 
diff --git a/lib/AST/AbstractConditionalOperator.cpp b/lib/AST/AbstractConditionalOperator.cpp
index f1136bb1e..dfe006879 100644
--- a/lib/AST/AbstractConditionalOperator.cpp
+++ b/lib/AST/AbstractConditionalOperator.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/BinaryConditionalOperator.h>
 #include <multiplier/AST/ConditionalOperator.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -85,17 +83,10 @@ bool AbstractConditionalOperator::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<AbstractConditionalOperator> AbstractConditionalOperator::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<AbstractConditionalOperator, ir::Operation>> AbstractConditionalOperator::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kAbstractConditionalOperatorDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<AbstractConditionalOperator, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<AbstractConditionalOperator> AbstractConditionalOperator::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kAbstractConditionalOperatorDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/AccessSpecDecl.cpp b/lib/AST/AccessSpecDecl.cpp
index df9840751..d93c03615 100644
--- a/lib/AST/AccessSpecDecl.cpp
+++ b/lib/AST/AccessSpecDecl.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -80,17 +78,10 @@ bool AccessSpecDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<AccessSpecDecl> AccessSpecDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<AccessSpecDecl, ir::Operation>> AccessSpecDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kAccessSpecDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<AccessSpecDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<AccessSpecDecl> AccessSpecDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kAccessSpecDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/AddrLabelExpr.cpp b/lib/AST/AddrLabelExpr.cpp
index 061d4d4b0..0871086c2 100644
--- a/lib/AST/AddrLabelExpr.cpp
+++ b/lib/AST/AddrLabelExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool AddrLabelExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<AddrLabelExpr> AddrLabelExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<AddrLabelExpr, ir::Operation>> AddrLabelExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kAddrLabelExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<AddrLabelExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<AddrLabelExpr> AddrLabelExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kAddrLabelExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ArrayInitIndexExpr.cpp b/lib/AST/ArrayInitIndexExpr.cpp
index e67c1b1fc..f964f0825 100644
--- a/lib/AST/ArrayInitIndexExpr.cpp
+++ b/lib/AST/ArrayInitIndexExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ArrayInitIndexExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ArrayInitIndexExpr> ArrayInitIndexExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ArrayInitIndexExpr, ir::Operation>> ArrayInitIndexExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kArrayInitIndexExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ArrayInitIndexExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ArrayInitIndexExpr> ArrayInitIndexExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kArrayInitIndexExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ArrayInitLoopExpr.cpp b/lib/AST/ArrayInitLoopExpr.cpp
index 446436401..7a43a0d02 100644
--- a/lib/AST/ArrayInitLoopExpr.cpp
+++ b/lib/AST/ArrayInitLoopExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ArrayInitLoopExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ArrayInitLoopExpr> ArrayInitLoopExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ArrayInitLoopExpr, ir::Operation>> ArrayInitLoopExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kArrayInitLoopExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ArrayInitLoopExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ArrayInitLoopExpr> ArrayInitLoopExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kArrayInitLoopExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ArraySubscriptExpr.cpp b/lib/AST/ArraySubscriptExpr.cpp
index 7fe7cc4b3..21b80aa40 100644
--- a/lib/AST/ArraySubscriptExpr.cpp
+++ b/lib/AST/ArraySubscriptExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ArraySubscriptExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ArraySubscriptExpr> ArraySubscriptExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ArraySubscriptExpr, ir::Operation>> ArraySubscriptExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kArraySubscriptExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ArraySubscriptExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ArraySubscriptExpr> ArraySubscriptExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kArraySubscriptExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ArrayTypeTraitExpr.cpp b/lib/AST/ArrayTypeTraitExpr.cpp
index c060c1c5a..2dc2fafe4 100644
--- a/lib/AST/ArrayTypeTraitExpr.cpp
+++ b/lib/AST/ArrayTypeTraitExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ArrayTypeTraitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ArrayTypeTraitExpr> ArrayTypeTraitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ArrayTypeTraitExpr, ir::Operation>> ArrayTypeTraitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kArrayTypeTraitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ArrayTypeTraitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ArrayTypeTraitExpr> ArrayTypeTraitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kArrayTypeTraitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/AsTypeExpr.cpp b/lib/AST/AsTypeExpr.cpp
index f84bbd4b4..4f6587825 100644
--- a/lib/AST/AsTypeExpr.cpp
+++ b/lib/AST/AsTypeExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool AsTypeExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<AsTypeExpr> AsTypeExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<AsTypeExpr, ir::Operation>> AsTypeExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kAsTypeExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<AsTypeExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<AsTypeExpr> AsTypeExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kAsTypeExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/AsmStmt.cpp b/lib/AST/AsmStmt.cpp
index 1ebe9a342..b2d644bc5 100644
--- a/lib/AST/AsmStmt.cpp
+++ b/lib/AST/AsmStmt.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/GCCAsmStmt.h>
 #include <multiplier/AST/MSAsmStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool AsmStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<AsmStmt> AsmStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<AsmStmt, ir::Operation>> AsmStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kAsmStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<AsmStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<AsmStmt> AsmStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kAsmStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/AtomicExpr.cpp b/lib/AST/AtomicExpr.cpp
index 0ac00e3c0..5c911063c 100644
--- a/lib/AST/AtomicExpr.cpp
+++ b/lib/AST/AtomicExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool AtomicExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<AtomicExpr> AtomicExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<AtomicExpr, ir::Operation>> AtomicExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kAtomicExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<AtomicExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<AtomicExpr> AtomicExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kAtomicExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/AttributedStmt.cpp b/lib/AST/AttributedStmt.cpp
index e55a8bcdf..58b1fb2a3 100644
--- a/lib/AST/AttributedStmt.cpp
+++ b/lib/AST/AttributedStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool AttributedStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<AttributedStmt> AttributedStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<AttributedStmt, ir::Operation>> AttributedStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kAttributedStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<AttributedStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<AttributedStmt> AttributedStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kAttributedStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/BaseUsingDecl.cpp b/lib/AST/BaseUsingDecl.cpp
index f764b3349..491adf6b8 100644
--- a/lib/AST/BaseUsingDecl.cpp
+++ b/lib/AST/BaseUsingDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/UsingDecl.h>
 #include <multiplier/AST/UsingEnumDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -85,17 +83,10 @@ bool BaseUsingDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<BaseUsingDecl> BaseUsingDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<BaseUsingDecl, ir::Operation>> BaseUsingDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kBaseUsingDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<BaseUsingDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<BaseUsingDecl> BaseUsingDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kBaseUsingDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/BinaryConditionalOperator.cpp b/lib/AST/BinaryConditionalOperator.cpp
index d6d38090a..15320f6d5 100644
--- a/lib/AST/BinaryConditionalOperator.cpp
+++ b/lib/AST/BinaryConditionalOperator.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool BinaryConditionalOperator::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<BinaryConditionalOperator> BinaryConditionalOperator::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<BinaryConditionalOperator, ir::Operation>> BinaryConditionalOperator::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kBinaryConditionalOperatorDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<BinaryConditionalOperator, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<BinaryConditionalOperator> BinaryConditionalOperator::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kBinaryConditionalOperatorDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/BinaryOperator.cpp b/lib/AST/BinaryOperator.cpp
index ec669ad3f..12c0ee3b4 100644
--- a/lib/AST/BinaryOperator.cpp
+++ b/lib/AST/BinaryOperator.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/ValueStmt.h>
 #include <multiplier/AST/CompoundAssignOperator.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool BinaryOperator::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<BinaryOperator> BinaryOperator::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<BinaryOperator, ir::Operation>> BinaryOperator::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kBinaryOperatorDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<BinaryOperator, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<BinaryOperator> BinaryOperator::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kBinaryOperatorDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/BindingDecl.cpp b/lib/AST/BindingDecl.cpp
index 301571d4f..8c8838c09 100644
--- a/lib/AST/BindingDecl.cpp
+++ b/lib/AST/BindingDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool BindingDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<BindingDecl> BindingDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<BindingDecl, ir::Operation>> BindingDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kBindingDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<BindingDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<BindingDecl> BindingDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kBindingDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/BlockDecl.cpp b/lib/AST/BlockDecl.cpp
index b7beaf0c3..5425bf1fb 100644
--- a/lib/AST/BlockDecl.cpp
+++ b/lib/AST/BlockDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/Type.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool BlockDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<BlockDecl> BlockDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<BlockDecl, ir::Operation>> BlockDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kBlockDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<BlockDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<BlockDecl> BlockDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kBlockDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/BlockExpr.cpp b/lib/AST/BlockExpr.cpp
index 0071298ec..0115db7ab 100644
--- a/lib/AST/BlockExpr.cpp
+++ b/lib/AST/BlockExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool BlockExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<BlockExpr> BlockExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<BlockExpr, ir::Operation>> BlockExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kBlockExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<BlockExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<BlockExpr> BlockExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kBlockExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/BreakStmt.cpp b/lib/AST/BreakStmt.cpp
index 67eee2e3b..06325e59e 100644
--- a/lib/AST/BreakStmt.cpp
+++ b/lib/AST/BreakStmt.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -80,17 +78,10 @@ bool BreakStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<BreakStmt> BreakStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<BreakStmt, ir::Operation>> BreakStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kBreakStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<BreakStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<BreakStmt> BreakStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kBreakStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/BuiltinBitCastExpr.cpp b/lib/AST/BuiltinBitCastExpr.cpp
index 33c590f10..b5524dcc4 100644
--- a/lib/AST/BuiltinBitCastExpr.cpp
+++ b/lib/AST/BuiltinBitCastExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool BuiltinBitCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<BuiltinBitCastExpr> BuiltinBitCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<BuiltinBitCastExpr, ir::Operation>> BuiltinBitCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kBuiltinBitCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<BuiltinBitCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<BuiltinBitCastExpr> BuiltinBitCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kBuiltinBitCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/BuiltinTemplateDecl.cpp b/lib/AST/BuiltinTemplateDecl.cpp
index 3632201b5..83d2ee70a 100644
--- a/lib/AST/BuiltinTemplateDecl.cpp
+++ b/lib/AST/BuiltinTemplateDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/TemplateDecl.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool BuiltinTemplateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<BuiltinTemplateDecl> BuiltinTemplateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<BuiltinTemplateDecl, ir::Operation>> BuiltinTemplateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kBuiltinTemplateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<BuiltinTemplateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<BuiltinTemplateDecl> BuiltinTemplateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kBuiltinTemplateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CStyleCastExpr.cpp b/lib/AST/CStyleCastExpr.cpp
index 4a65dd8d2..0d70f7052 100644
--- a/lib/AST/CStyleCastExpr.cpp
+++ b/lib/AST/CStyleCastExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool CStyleCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CStyleCastExpr> CStyleCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CStyleCastExpr, ir::Operation>> CStyleCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCStyleCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CStyleCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CStyleCastExpr> CStyleCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCStyleCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CUDAKernelCallExpr.cpp b/lib/AST/CUDAKernelCallExpr.cpp
index fe2cb3bb8..edb23f430 100644
--- a/lib/AST/CUDAKernelCallExpr.cpp
+++ b/lib/AST/CUDAKernelCallExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CUDAKernelCallExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CUDAKernelCallExpr> CUDAKernelCallExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CUDAKernelCallExpr, ir::Operation>> CUDAKernelCallExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCUDAKernelCallExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CUDAKernelCallExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CUDAKernelCallExpr> CUDAKernelCallExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCUDAKernelCallExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXAddrspaceCastExpr.cpp b/lib/AST/CXXAddrspaceCastExpr.cpp
index 2c4420267..0c44229bc 100644
--- a/lib/AST/CXXAddrspaceCastExpr.cpp
+++ b/lib/AST/CXXAddrspaceCastExpr.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -85,17 +83,10 @@ bool CXXAddrspaceCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXAddrspaceCastExpr> CXXAddrspaceCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXAddrspaceCastExpr, ir::Operation>> CXXAddrspaceCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXAddrspaceCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXAddrspaceCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXAddrspaceCastExpr> CXXAddrspaceCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXAddrspaceCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXBindTemporaryExpr.cpp b/lib/AST/CXXBindTemporaryExpr.cpp
index 2f8bd7ea9..18387a0bf 100644
--- a/lib/AST/CXXBindTemporaryExpr.cpp
+++ b/lib/AST/CXXBindTemporaryExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXBindTemporaryExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXBindTemporaryExpr> CXXBindTemporaryExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXBindTemporaryExpr, ir::Operation>> CXXBindTemporaryExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXBindTemporaryExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXBindTemporaryExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXBindTemporaryExpr> CXXBindTemporaryExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXBindTemporaryExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXBoolLiteralExpr.cpp b/lib/AST/CXXBoolLiteralExpr.cpp
index d643d3478..3985db41f 100644
--- a/lib/AST/CXXBoolLiteralExpr.cpp
+++ b/lib/AST/CXXBoolLiteralExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXBoolLiteralExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXBoolLiteralExpr> CXXBoolLiteralExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXBoolLiteralExpr, ir::Operation>> CXXBoolLiteralExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXBoolLiteralExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXBoolLiteralExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXBoolLiteralExpr> CXXBoolLiteralExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXBoolLiteralExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXCatchStmt.cpp b/lib/AST/CXXCatchStmt.cpp
index 70f696d69..2d39aac3c 100644
--- a/lib/AST/CXXCatchStmt.cpp
+++ b/lib/AST/CXXCatchStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXCatchStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXCatchStmt> CXXCatchStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXCatchStmt, ir::Operation>> CXXCatchStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXCatchStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXCatchStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXCatchStmt> CXXCatchStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXCatchStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXConstCastExpr.cpp b/lib/AST/CXXConstCastExpr.cpp
index 12c20d418..9d01b4a4d 100644
--- a/lib/AST/CXXConstCastExpr.cpp
+++ b/lib/AST/CXXConstCastExpr.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -85,17 +83,10 @@ bool CXXConstCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXConstCastExpr> CXXConstCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXConstCastExpr, ir::Operation>> CXXConstCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXConstCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXConstCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXConstCastExpr> CXXConstCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXConstCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXConstructExpr.cpp b/lib/AST/CXXConstructExpr.cpp
index 55375a224..778627caf 100644
--- a/lib/AST/CXXConstructExpr.cpp
+++ b/lib/AST/CXXConstructExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/ValueStmt.h>
 #include <multiplier/AST/CXXTemporaryObjectExpr.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Stmt.h"
@@ -86,17 +84,10 @@ bool CXXConstructExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXConstructExpr> CXXConstructExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXConstructExpr, ir::Operation>> CXXConstructExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXConstructExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXConstructExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXConstructExpr> CXXConstructExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXConstructExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXConstructorDecl.cpp b/lib/AST/CXXConstructorDecl.cpp
index f4ab1f284..4742d8ade 100644
--- a/lib/AST/CXXConstructorDecl.cpp
+++ b/lib/AST/CXXConstructorDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -87,17 +85,10 @@ bool CXXConstructorDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXConstructorDecl> CXXConstructorDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXConstructorDecl, ir::Operation>> CXXConstructorDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kCXXConstructorDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXConstructorDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXConstructorDecl> CXXConstructorDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kCXXConstructorDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXConversionDecl.cpp b/lib/AST/CXXConversionDecl.cpp
index 82dd4f3b5..fcf330c86 100644
--- a/lib/AST/CXXConversionDecl.cpp
+++ b/lib/AST/CXXConversionDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -87,17 +85,10 @@ bool CXXConversionDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXConversionDecl> CXXConversionDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXConversionDecl, ir::Operation>> CXXConversionDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kCXXConversionDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXConversionDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXConversionDecl> CXXConversionDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kCXXConversionDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXDeductionGuideDecl.cpp b/lib/AST/CXXDeductionGuideDecl.cpp
index 27390b01c..937c15e5c 100644
--- a/lib/AST/CXXDeductionGuideDecl.cpp
+++ b/lib/AST/CXXDeductionGuideDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -87,17 +85,10 @@ bool CXXDeductionGuideDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXDeductionGuideDecl> CXXDeductionGuideDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXDeductionGuideDecl, ir::Operation>> CXXDeductionGuideDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kCXXDeductionGuideDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXDeductionGuideDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXDeductionGuideDecl> CXXDeductionGuideDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kCXXDeductionGuideDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXDefaultArgExpr.cpp b/lib/AST/CXXDefaultArgExpr.cpp
index 9f25ad81f..784e871cc 100644
--- a/lib/AST/CXXDefaultArgExpr.cpp
+++ b/lib/AST/CXXDefaultArgExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXDefaultArgExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXDefaultArgExpr> CXXDefaultArgExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXDefaultArgExpr, ir::Operation>> CXXDefaultArgExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXDefaultArgExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXDefaultArgExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXDefaultArgExpr> CXXDefaultArgExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXDefaultArgExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXDefaultInitExpr.cpp b/lib/AST/CXXDefaultInitExpr.cpp
index 27289b9d0..af8ee614d 100644
--- a/lib/AST/CXXDefaultInitExpr.cpp
+++ b/lib/AST/CXXDefaultInitExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXDefaultInitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXDefaultInitExpr> CXXDefaultInitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXDefaultInitExpr, ir::Operation>> CXXDefaultInitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXDefaultInitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXDefaultInitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXDefaultInitExpr> CXXDefaultInitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXDefaultInitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXDeleteExpr.cpp b/lib/AST/CXXDeleteExpr.cpp
index 8cc08f371..31d516952 100644
--- a/lib/AST/CXXDeleteExpr.cpp
+++ b/lib/AST/CXXDeleteExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool CXXDeleteExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXDeleteExpr> CXXDeleteExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXDeleteExpr, ir::Operation>> CXXDeleteExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXDeleteExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXDeleteExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXDeleteExpr> CXXDeleteExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXDeleteExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXDependentScopeMemberExpr.cpp b/lib/AST/CXXDependentScopeMemberExpr.cpp
index 17c88d601..36498de6f 100644
--- a/lib/AST/CXXDependentScopeMemberExpr.cpp
+++ b/lib/AST/CXXDependentScopeMemberExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool CXXDependentScopeMemberExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXDependentScopeMemberExpr> CXXDependentScopeMemberExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXDependentScopeMemberExpr, ir::Operation>> CXXDependentScopeMemberExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXDependentScopeMemberExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXDependentScopeMemberExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXDependentScopeMemberExpr> CXXDependentScopeMemberExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXDependentScopeMemberExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXDestructorDecl.cpp b/lib/AST/CXXDestructorDecl.cpp
index 62c2b2558..ec204e34b 100644
--- a/lib/AST/CXXDestructorDecl.cpp
+++ b/lib/AST/CXXDestructorDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -87,17 +85,10 @@ bool CXXDestructorDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXDestructorDecl> CXXDestructorDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXDestructorDecl, ir::Operation>> CXXDestructorDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kCXXDestructorDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXDestructorDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXDestructorDecl> CXXDestructorDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kCXXDestructorDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXDynamicCastExpr.cpp b/lib/AST/CXXDynamicCastExpr.cpp
index 9aa5f2f9b..8747b6894 100644
--- a/lib/AST/CXXDynamicCastExpr.cpp
+++ b/lib/AST/CXXDynamicCastExpr.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -85,17 +83,10 @@ bool CXXDynamicCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXDynamicCastExpr> CXXDynamicCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXDynamicCastExpr, ir::Operation>> CXXDynamicCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXDynamicCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXDynamicCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXDynamicCastExpr> CXXDynamicCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXDynamicCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXFoldExpr.cpp b/lib/AST/CXXFoldExpr.cpp
index e3e3cdd9f..4e3dc4a74 100644
--- a/lib/AST/CXXFoldExpr.cpp
+++ b/lib/AST/CXXFoldExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/UnresolvedLookupExpr.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXFoldExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXFoldExpr> CXXFoldExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXFoldExpr, ir::Operation>> CXXFoldExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXFoldExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXFoldExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXFoldExpr> CXXFoldExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXFoldExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXForRangeStmt.cpp b/lib/AST/CXXForRangeStmt.cpp
index 16519bbb1..b958c4800 100644
--- a/lib/AST/CXXForRangeStmt.cpp
+++ b/lib/AST/CXXForRangeStmt.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXForRangeStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXForRangeStmt> CXXForRangeStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXForRangeStmt, ir::Operation>> CXXForRangeStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXForRangeStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXForRangeStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXForRangeStmt> CXXForRangeStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXForRangeStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXFunctionalCastExpr.cpp b/lib/AST/CXXFunctionalCastExpr.cpp
index 4e02052bb..0ac3437b9 100644
--- a/lib/AST/CXXFunctionalCastExpr.cpp
+++ b/lib/AST/CXXFunctionalCastExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool CXXFunctionalCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXFunctionalCastExpr> CXXFunctionalCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXFunctionalCastExpr, ir::Operation>> CXXFunctionalCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXFunctionalCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXFunctionalCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXFunctionalCastExpr> CXXFunctionalCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXFunctionalCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXInheritedCtorInitExpr.cpp b/lib/AST/CXXInheritedCtorInitExpr.cpp
index 72d5fad76..0cc62b029 100644
--- a/lib/AST/CXXInheritedCtorInitExpr.cpp
+++ b/lib/AST/CXXInheritedCtorInitExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXInheritedCtorInitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXInheritedCtorInitExpr> CXXInheritedCtorInitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXInheritedCtorInitExpr, ir::Operation>> CXXInheritedCtorInitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXInheritedCtorInitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXInheritedCtorInitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXInheritedCtorInitExpr> CXXInheritedCtorInitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXInheritedCtorInitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXMemberCallExpr.cpp b/lib/AST/CXXMemberCallExpr.cpp
index fb899d8d0..344ad1f29 100644
--- a/lib/AST/CXXMemberCallExpr.cpp
+++ b/lib/AST/CXXMemberCallExpr.cpp
@@ -17,8 +17,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -86,17 +84,10 @@ bool CXXMemberCallExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXMemberCallExpr> CXXMemberCallExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXMemberCallExpr, ir::Operation>> CXXMemberCallExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXMemberCallExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXMemberCallExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXMemberCallExpr> CXXMemberCallExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXMemberCallExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXMethodDecl.cpp b/lib/AST/CXXMethodDecl.cpp
index 0463897fe..965736ee8 100644
--- a/lib/AST/CXXMethodDecl.cpp
+++ b/lib/AST/CXXMethodDecl.cpp
@@ -20,8 +20,6 @@
 #include <multiplier/AST/CXXConversionDecl.h>
 #include <multiplier/AST/CXXDestructorDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -92,17 +90,10 @@ bool CXXMethodDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXMethodDecl> CXXMethodDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXMethodDecl, ir::Operation>> CXXMethodDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kCXXMethodDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXMethodDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXMethodDecl> CXXMethodDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kCXXMethodDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXNamedCastExpr.cpp b/lib/AST/CXXNamedCastExpr.cpp
index 6ac0f15ce..adff17897 100644
--- a/lib/AST/CXXNamedCastExpr.cpp
+++ b/lib/AST/CXXNamedCastExpr.cpp
@@ -20,8 +20,6 @@
 #include <multiplier/AST/CXXReinterpretCastExpr.h>
 #include <multiplier/AST/CXXStaticCastExpr.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Stmt.h"
@@ -94,17 +92,10 @@ bool CXXNamedCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXNamedCastExpr> CXXNamedCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXNamedCastExpr, ir::Operation>> CXXNamedCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXNamedCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXNamedCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXNamedCastExpr> CXXNamedCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXNamedCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXNewExpr.cpp b/lib/AST/CXXNewExpr.cpp
index 3e06a57ef..d34acfcda 100644
--- a/lib/AST/CXXNewExpr.cpp
+++ b/lib/AST/CXXNewExpr.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Stmt.h"
@@ -86,17 +84,10 @@ bool CXXNewExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXNewExpr> CXXNewExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXNewExpr, ir::Operation>> CXXNewExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXNewExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXNewExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXNewExpr> CXXNewExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXNewExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXNoexceptExpr.cpp b/lib/AST/CXXNoexceptExpr.cpp
index 6a754b00f..2acc124b9 100644
--- a/lib/AST/CXXNoexceptExpr.cpp
+++ b/lib/AST/CXXNoexceptExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXNoexceptExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXNoexceptExpr> CXXNoexceptExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXNoexceptExpr, ir::Operation>> CXXNoexceptExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXNoexceptExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXNoexceptExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXNoexceptExpr> CXXNoexceptExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXNoexceptExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXNullPtrLiteralExpr.cpp b/lib/AST/CXXNullPtrLiteralExpr.cpp
index c75b17b90..a872cd1d4 100644
--- a/lib/AST/CXXNullPtrLiteralExpr.cpp
+++ b/lib/AST/CXXNullPtrLiteralExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXNullPtrLiteralExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXNullPtrLiteralExpr> CXXNullPtrLiteralExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXNullPtrLiteralExpr, ir::Operation>> CXXNullPtrLiteralExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXNullPtrLiteralExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXNullPtrLiteralExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXNullPtrLiteralExpr> CXXNullPtrLiteralExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXNullPtrLiteralExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXOperatorCallExpr.cpp b/lib/AST/CXXOperatorCallExpr.cpp
index 73a25e6b5..405cd356b 100644
--- a/lib/AST/CXXOperatorCallExpr.cpp
+++ b/lib/AST/CXXOperatorCallExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXOperatorCallExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXOperatorCallExpr> CXXOperatorCallExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXOperatorCallExpr, ir::Operation>> CXXOperatorCallExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXOperatorCallExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXOperatorCallExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXOperatorCallExpr> CXXOperatorCallExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXOperatorCallExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXParenListInitExpr.cpp b/lib/AST/CXXParenListInitExpr.cpp
index ae841fe8e..77fccb657 100644
--- a/lib/AST/CXXParenListInitExpr.cpp
+++ b/lib/AST/CXXParenListInitExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXParenListInitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXParenListInitExpr> CXXParenListInitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXParenListInitExpr, ir::Operation>> CXXParenListInitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXParenListInitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXParenListInitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXParenListInitExpr> CXXParenListInitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXParenListInitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXPseudoDestructorExpr.cpp b/lib/AST/CXXPseudoDestructorExpr.cpp
index 940a454e2..632ca919b 100644
--- a/lib/AST/CXXPseudoDestructorExpr.cpp
+++ b/lib/AST/CXXPseudoDestructorExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXPseudoDestructorExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXPseudoDestructorExpr> CXXPseudoDestructorExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXPseudoDestructorExpr, ir::Operation>> CXXPseudoDestructorExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXPseudoDestructorExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXPseudoDestructorExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXPseudoDestructorExpr> CXXPseudoDestructorExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXPseudoDestructorExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXRecordDecl.cpp b/lib/AST/CXXRecordDecl.cpp
index f2376a126..9be62e5e6 100644
--- a/lib/AST/CXXRecordDecl.cpp
+++ b/lib/AST/CXXRecordDecl.cpp
@@ -27,8 +27,6 @@
 #include <multiplier/AST/ClassTemplatePartialSpecializationDecl.h>
 #include <multiplier/AST/ClassTemplateSpecializationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -98,17 +96,10 @@ bool CXXRecordDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXRecordDecl> CXXRecordDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXRecordDecl, ir::Operation>> CXXRecordDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kCXXRecordDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXRecordDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXRecordDecl> CXXRecordDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kCXXRecordDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXReinterpretCastExpr.cpp b/lib/AST/CXXReinterpretCastExpr.cpp
index 6cb383e12..2826466b1 100644
--- a/lib/AST/CXXReinterpretCastExpr.cpp
+++ b/lib/AST/CXXReinterpretCastExpr.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -85,17 +83,10 @@ bool CXXReinterpretCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXReinterpretCastExpr> CXXReinterpretCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXReinterpretCastExpr, ir::Operation>> CXXReinterpretCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXReinterpretCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXReinterpretCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXReinterpretCastExpr> CXXReinterpretCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXReinterpretCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXRewrittenBinaryOperator.cpp b/lib/AST/CXXRewrittenBinaryOperator.cpp
index b6fcf21b8..f86e3ad26 100644
--- a/lib/AST/CXXRewrittenBinaryOperator.cpp
+++ b/lib/AST/CXXRewrittenBinaryOperator.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXRewrittenBinaryOperator::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXRewrittenBinaryOperator> CXXRewrittenBinaryOperator::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXRewrittenBinaryOperator, ir::Operation>> CXXRewrittenBinaryOperator::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXRewrittenBinaryOperatorDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXRewrittenBinaryOperator, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXRewrittenBinaryOperator> CXXRewrittenBinaryOperator::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXRewrittenBinaryOperatorDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXScalarValueInitExpr.cpp b/lib/AST/CXXScalarValueInitExpr.cpp
index c35c14624..9d8345439 100644
--- a/lib/AST/CXXScalarValueInitExpr.cpp
+++ b/lib/AST/CXXScalarValueInitExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXScalarValueInitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXScalarValueInitExpr> CXXScalarValueInitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXScalarValueInitExpr, ir::Operation>> CXXScalarValueInitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXScalarValueInitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXScalarValueInitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXScalarValueInitExpr> CXXScalarValueInitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXScalarValueInitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXStaticCastExpr.cpp b/lib/AST/CXXStaticCastExpr.cpp
index 18b6c806e..a192c99a0 100644
--- a/lib/AST/CXXStaticCastExpr.cpp
+++ b/lib/AST/CXXStaticCastExpr.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -85,17 +83,10 @@ bool CXXStaticCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXStaticCastExpr> CXXStaticCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXStaticCastExpr, ir::Operation>> CXXStaticCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXStaticCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXStaticCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXStaticCastExpr> CXXStaticCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXStaticCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXStdInitializerListExpr.cpp b/lib/AST/CXXStdInitializerListExpr.cpp
index 047ff1ca3..39f01a4a2 100644
--- a/lib/AST/CXXStdInitializerListExpr.cpp
+++ b/lib/AST/CXXStdInitializerListExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXStdInitializerListExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXStdInitializerListExpr> CXXStdInitializerListExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXStdInitializerListExpr, ir::Operation>> CXXStdInitializerListExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXStdInitializerListExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXStdInitializerListExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXStdInitializerListExpr> CXXStdInitializerListExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXStdInitializerListExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXTemporaryObjectExpr.cpp b/lib/AST/CXXTemporaryObjectExpr.cpp
index f0bdb0041..ca6194f8f 100644
--- a/lib/AST/CXXTemporaryObjectExpr.cpp
+++ b/lib/AST/CXXTemporaryObjectExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXTemporaryObjectExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXTemporaryObjectExpr> CXXTemporaryObjectExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXTemporaryObjectExpr, ir::Operation>> CXXTemporaryObjectExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXTemporaryObjectExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXTemporaryObjectExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXTemporaryObjectExpr> CXXTemporaryObjectExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXTemporaryObjectExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXThisExpr.cpp b/lib/AST/CXXThisExpr.cpp
index dfae98c36..076d905f5 100644
--- a/lib/AST/CXXThisExpr.cpp
+++ b/lib/AST/CXXThisExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXThisExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXThisExpr> CXXThisExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXThisExpr, ir::Operation>> CXXThisExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXThisExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXThisExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXThisExpr> CXXThisExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXThisExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXThrowExpr.cpp b/lib/AST/CXXThrowExpr.cpp
index 3495c3866..56a26cb3d 100644
--- a/lib/AST/CXXThrowExpr.cpp
+++ b/lib/AST/CXXThrowExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXThrowExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXThrowExpr> CXXThrowExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXThrowExpr, ir::Operation>> CXXThrowExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXThrowExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXThrowExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXThrowExpr> CXXThrowExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXThrowExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXTryStmt.cpp b/lib/AST/CXXTryStmt.cpp
index 3c6cfc15a..49d5f04e3 100644
--- a/lib/AST/CXXTryStmt.cpp
+++ b/lib/AST/CXXTryStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CXXTryStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXTryStmt> CXXTryStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXTryStmt, ir::Operation>> CXXTryStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXTryStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXTryStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXTryStmt> CXXTryStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXTryStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXTypeidExpr.cpp b/lib/AST/CXXTypeidExpr.cpp
index b2748e70d..e7b6a8feb 100644
--- a/lib/AST/CXXTypeidExpr.cpp
+++ b/lib/AST/CXXTypeidExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXTypeidExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXTypeidExpr> CXXTypeidExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXTypeidExpr, ir::Operation>> CXXTypeidExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXTypeidExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXTypeidExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXTypeidExpr> CXXTypeidExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXTypeidExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXUnresolvedConstructExpr.cpp b/lib/AST/CXXUnresolvedConstructExpr.cpp
index ec028bb80..65df9b7cd 100644
--- a/lib/AST/CXXUnresolvedConstructExpr.cpp
+++ b/lib/AST/CXXUnresolvedConstructExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CXXUnresolvedConstructExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXUnresolvedConstructExpr> CXXUnresolvedConstructExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXUnresolvedConstructExpr, ir::Operation>> CXXUnresolvedConstructExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXUnresolvedConstructExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXUnresolvedConstructExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXUnresolvedConstructExpr> CXXUnresolvedConstructExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXUnresolvedConstructExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CXXUuidofExpr.cpp b/lib/AST/CXXUuidofExpr.cpp
index 80e8a18e5..89294f16b 100644
--- a/lib/AST/CXXUuidofExpr.cpp
+++ b/lib/AST/CXXUuidofExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool CXXUuidofExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CXXUuidofExpr> CXXUuidofExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CXXUuidofExpr, ir::Operation>> CXXUuidofExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCXXUuidofExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CXXUuidofExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CXXUuidofExpr> CXXUuidofExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCXXUuidofExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CallExpr.cpp b/lib/AST/CallExpr.cpp
index 9ffba1244..154bbaf93 100644
--- a/lib/AST/CallExpr.cpp
+++ b/lib/AST/CallExpr.cpp
@@ -20,8 +20,6 @@
 #include <multiplier/AST/CXXOperatorCallExpr.h>
 #include <multiplier/AST/UserDefinedLiteral.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -93,17 +91,10 @@ bool CallExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CallExpr> CallExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CallExpr, ir::Operation>> CallExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCallExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CallExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CallExpr> CallExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCallExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CapturedDecl.cpp b/lib/AST/CapturedDecl.cpp
index d7179cb57..c2fa0528c 100644
--- a/lib/AST/CapturedDecl.cpp
+++ b/lib/AST/CapturedDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool CapturedDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CapturedDecl> CapturedDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CapturedDecl, ir::Operation>> CapturedDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kCapturedDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CapturedDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CapturedDecl> CapturedDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kCapturedDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CapturedStmt.cpp b/lib/AST/CapturedStmt.cpp
index 27cae8ac1..26756785a 100644
--- a/lib/AST/CapturedStmt.cpp
+++ b/lib/AST/CapturedStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CapturedStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CapturedStmt> CapturedStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CapturedStmt, ir::Operation>> CapturedStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCapturedStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CapturedStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CapturedStmt> CapturedStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCapturedStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CaseStmt.cpp b/lib/AST/CaseStmt.cpp
index 72e827fe8..aa038b267 100644
--- a/lib/AST/CaseStmt.cpp
+++ b/lib/AST/CaseStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/SwitchCase.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CaseStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CaseStmt> CaseStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CaseStmt, ir::Operation>> CaseStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCaseStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CaseStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CaseStmt> CaseStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCaseStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CastExpr.cpp b/lib/AST/CastExpr.cpp
index 605bfcec1..ce0c32b65 100644
--- a/lib/AST/CastExpr.cpp
+++ b/lib/AST/CastExpr.cpp
@@ -25,8 +25,6 @@
 #include <multiplier/AST/ImplicitCastExpr.h>
 #include <multiplier/AST/ObjCBridgedCastExpr.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -103,17 +101,10 @@ bool CastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CastExpr> CastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CastExpr, ir::Operation>> CastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CastExpr> CastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CharacterLiteral.cpp b/lib/AST/CharacterLiteral.cpp
index 8589685d8..f0a11d083 100644
--- a/lib/AST/CharacterLiteral.cpp
+++ b/lib/AST/CharacterLiteral.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CharacterLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CharacterLiteral> CharacterLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CharacterLiteral, ir::Operation>> CharacterLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCharacterLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CharacterLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CharacterLiteral> CharacterLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCharacterLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ChooseExpr.cpp b/lib/AST/ChooseExpr.cpp
index e08e5e3b8..8d68865cd 100644
--- a/lib/AST/ChooseExpr.cpp
+++ b/lib/AST/ChooseExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ChooseExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ChooseExpr> ChooseExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ChooseExpr, ir::Operation>> ChooseExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kChooseExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ChooseExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ChooseExpr> ChooseExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kChooseExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ClassTemplateDecl.cpp b/lib/AST/ClassTemplateDecl.cpp
index 471a10658..fdc8f55cb 100644
--- a/lib/AST/ClassTemplateDecl.cpp
+++ b/lib/AST/ClassTemplateDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/TemplateDecl.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool ClassTemplateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ClassTemplateDecl> ClassTemplateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ClassTemplateDecl, ir::Operation>> ClassTemplateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kClassTemplateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ClassTemplateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ClassTemplateDecl> ClassTemplateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kClassTemplateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ClassTemplatePartialSpecializationDecl.cpp b/lib/AST/ClassTemplatePartialSpecializationDecl.cpp
index 7b781e1c5..f226e9250 100644
--- a/lib/AST/ClassTemplatePartialSpecializationDecl.cpp
+++ b/lib/AST/ClassTemplatePartialSpecializationDecl.cpp
@@ -20,8 +20,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/TypeDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -89,17 +87,10 @@ bool ClassTemplatePartialSpecializationDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ClassTemplatePartialSpecializationDecl> ClassTemplatePartialSpecializationDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ClassTemplatePartialSpecializationDecl, ir::Operation>> ClassTemplatePartialSpecializationDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kClassTemplatePartialSpecializationDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ClassTemplatePartialSpecializationDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ClassTemplatePartialSpecializationDecl> ClassTemplatePartialSpecializationDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kClassTemplatePartialSpecializationDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ClassTemplateSpecializationDecl.cpp b/lib/AST/ClassTemplateSpecializationDecl.cpp
index d0b62391a..44b8537a0 100644
--- a/lib/AST/ClassTemplateSpecializationDecl.cpp
+++ b/lib/AST/ClassTemplateSpecializationDecl.cpp
@@ -20,8 +20,6 @@
 #include <multiplier/AST/TypeDecl.h>
 #include <multiplier/AST/ClassTemplatePartialSpecializationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -90,17 +88,10 @@ bool ClassTemplateSpecializationDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ClassTemplateSpecializationDecl> ClassTemplateSpecializationDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ClassTemplateSpecializationDecl, ir::Operation>> ClassTemplateSpecializationDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kClassTemplateSpecializationDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ClassTemplateSpecializationDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ClassTemplateSpecializationDecl> ClassTemplateSpecializationDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kClassTemplateSpecializationDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CoawaitExpr.cpp b/lib/AST/CoawaitExpr.cpp
index a79c7a61c..4edc5acb1 100644
--- a/lib/AST/CoawaitExpr.cpp
+++ b/lib/AST/CoawaitExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CoawaitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CoawaitExpr> CoawaitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CoawaitExpr, ir::Operation>> CoawaitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCoawaitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CoawaitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CoawaitExpr> CoawaitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCoawaitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CompoundAssignOperator.cpp b/lib/AST/CompoundAssignOperator.cpp
index 1a97a99f6..fd61985b9 100644
--- a/lib/AST/CompoundAssignOperator.cpp
+++ b/lib/AST/CompoundAssignOperator.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool CompoundAssignOperator::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CompoundAssignOperator> CompoundAssignOperator::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CompoundAssignOperator, ir::Operation>> CompoundAssignOperator::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCompoundAssignOperatorDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CompoundAssignOperator, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CompoundAssignOperator> CompoundAssignOperator::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCompoundAssignOperatorDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CompoundLiteralExpr.cpp b/lib/AST/CompoundLiteralExpr.cpp
index 2c1aae264..fdb6f946f 100644
--- a/lib/AST/CompoundLiteralExpr.cpp
+++ b/lib/AST/CompoundLiteralExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool CompoundLiteralExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CompoundLiteralExpr> CompoundLiteralExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CompoundLiteralExpr, ir::Operation>> CompoundLiteralExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCompoundLiteralExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CompoundLiteralExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CompoundLiteralExpr> CompoundLiteralExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCompoundLiteralExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CompoundStmt.cpp b/lib/AST/CompoundStmt.cpp
index f3086c6a2..fec3f6b70 100644
--- a/lib/AST/CompoundStmt.cpp
+++ b/lib/AST/CompoundStmt.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -80,17 +78,10 @@ bool CompoundStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CompoundStmt> CompoundStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CompoundStmt, ir::Operation>> CompoundStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCompoundStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CompoundStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CompoundStmt> CompoundStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCompoundStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ConceptDecl.cpp b/lib/AST/ConceptDecl.cpp
index fd97f1178..f25399d01 100644
--- a/lib/AST/ConceptDecl.cpp
+++ b/lib/AST/ConceptDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/TemplateDecl.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool ConceptDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ConceptDecl> ConceptDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ConceptDecl, ir::Operation>> ConceptDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kConceptDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ConceptDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ConceptDecl> ConceptDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kConceptDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ConceptSpecializationExpr.cpp b/lib/AST/ConceptSpecializationExpr.cpp
index dc31f79a0..b29c1efd0 100644
--- a/lib/AST/ConceptSpecializationExpr.cpp
+++ b/lib/AST/ConceptSpecializationExpr.cpp
@@ -17,8 +17,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -86,17 +84,10 @@ bool ConceptSpecializationExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ConceptSpecializationExpr> ConceptSpecializationExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ConceptSpecializationExpr, ir::Operation>> ConceptSpecializationExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kConceptSpecializationExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ConceptSpecializationExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ConceptSpecializationExpr> ConceptSpecializationExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kConceptSpecializationExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ConditionalOperator.cpp b/lib/AST/ConditionalOperator.cpp
index c44a18df0..3f843e0bc 100644
--- a/lib/AST/ConditionalOperator.cpp
+++ b/lib/AST/ConditionalOperator.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ConditionalOperator::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ConditionalOperator> ConditionalOperator::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ConditionalOperator, ir::Operation>> ConditionalOperator::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kConditionalOperatorDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ConditionalOperator, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ConditionalOperator> ConditionalOperator::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kConditionalOperatorDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ConstantExpr.cpp b/lib/AST/ConstantExpr.cpp
index 26becfbc6..405d25fa2 100644
--- a/lib/AST/ConstantExpr.cpp
+++ b/lib/AST/ConstantExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ConstantExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ConstantExpr> ConstantExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ConstantExpr, ir::Operation>> ConstantExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kConstantExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ConstantExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ConstantExpr> ConstantExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kConstantExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ConstructorUsingShadowDecl.cpp b/lib/AST/ConstructorUsingShadowDecl.cpp
index 87e041512..a9c59b9cd 100644
--- a/lib/AST/ConstructorUsingShadowDecl.cpp
+++ b/lib/AST/ConstructorUsingShadowDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/UsingShadowDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool ConstructorUsingShadowDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ConstructorUsingShadowDecl> ConstructorUsingShadowDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ConstructorUsingShadowDecl, ir::Operation>> ConstructorUsingShadowDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kConstructorUsingShadowDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ConstructorUsingShadowDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ConstructorUsingShadowDecl> ConstructorUsingShadowDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kConstructorUsingShadowDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ContinueStmt.cpp b/lib/AST/ContinueStmt.cpp
index af49dbb74..c36811cab 100644
--- a/lib/AST/ContinueStmt.cpp
+++ b/lib/AST/ContinueStmt.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -80,17 +78,10 @@ bool ContinueStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ContinueStmt> ContinueStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ContinueStmt, ir::Operation>> ContinueStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kContinueStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ContinueStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ContinueStmt> ContinueStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kContinueStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ConvertVectorExpr.cpp b/lib/AST/ConvertVectorExpr.cpp
index 28df1836f..b7b9b1086 100644
--- a/lib/AST/ConvertVectorExpr.cpp
+++ b/lib/AST/ConvertVectorExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ConvertVectorExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ConvertVectorExpr> ConvertVectorExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ConvertVectorExpr, ir::Operation>> ConvertVectorExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kConvertVectorExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ConvertVectorExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ConvertVectorExpr> ConvertVectorExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kConvertVectorExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CoreturnStmt.cpp b/lib/AST/CoreturnStmt.cpp
index e1b699115..16114c533 100644
--- a/lib/AST/CoreturnStmt.cpp
+++ b/lib/AST/CoreturnStmt.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool CoreturnStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CoreturnStmt> CoreturnStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CoreturnStmt, ir::Operation>> CoreturnStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCoreturnStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CoreturnStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CoreturnStmt> CoreturnStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCoreturnStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CoroutineBodyStmt.cpp b/lib/AST/CoroutineBodyStmt.cpp
index 4fe092c0d..9f0d1a22d 100644
--- a/lib/AST/CoroutineBodyStmt.cpp
+++ b/lib/AST/CoroutineBodyStmt.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CoroutineBodyStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CoroutineBodyStmt> CoroutineBodyStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CoroutineBodyStmt, ir::Operation>> CoroutineBodyStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCoroutineBodyStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CoroutineBodyStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CoroutineBodyStmt> CoroutineBodyStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCoroutineBodyStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CoroutineSuspendExpr.cpp b/lib/AST/CoroutineSuspendExpr.cpp
index cb652f3ec..b6f6e587f 100644
--- a/lib/AST/CoroutineSuspendExpr.cpp
+++ b/lib/AST/CoroutineSuspendExpr.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/AST/CoawaitExpr.h>
 #include <multiplier/AST/CoyieldExpr.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -86,17 +84,10 @@ bool CoroutineSuspendExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CoroutineSuspendExpr> CoroutineSuspendExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CoroutineSuspendExpr, ir::Operation>> CoroutineSuspendExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCoroutineSuspendExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CoroutineSuspendExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CoroutineSuspendExpr> CoroutineSuspendExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCoroutineSuspendExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/CoyieldExpr.cpp b/lib/AST/CoyieldExpr.cpp
index d3ea01cc7..ffb8f4df6 100644
--- a/lib/AST/CoyieldExpr.cpp
+++ b/lib/AST/CoyieldExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool CoyieldExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<CoyieldExpr> CoyieldExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<CoyieldExpr, ir::Operation>> CoyieldExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kCoyieldExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<CoyieldExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<CoyieldExpr> CoyieldExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kCoyieldExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index 5099b5244..dd51704ee 100644
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../File.h"
 #include "../Fragment.h"
diff --git a/lib/AST/DeclRefExpr.cpp b/lib/AST/DeclRefExpr.cpp
index 72b8626c4..679785d2d 100644
--- a/lib/AST/DeclRefExpr.cpp
+++ b/lib/AST/DeclRefExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool DeclRefExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DeclRefExpr> DeclRefExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DeclRefExpr, ir::Operation>> DeclRefExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kDeclRefExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DeclRefExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DeclRefExpr> DeclRefExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kDeclRefExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/DeclStmt.cpp b/lib/AST/DeclStmt.cpp
index 97381cbb8..28502d28f 100644
--- a/lib/AST/DeclStmt.cpp
+++ b/lib/AST/DeclStmt.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -80,17 +78,10 @@ bool DeclStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DeclStmt> DeclStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DeclStmt, ir::Operation>> DeclStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kDeclStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DeclStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DeclStmt> DeclStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kDeclStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/DeclaratorDecl.cpp b/lib/AST/DeclaratorDecl.cpp
index 3564a2947..26a5d3ee6 100644
--- a/lib/AST/DeclaratorDecl.cpp
+++ b/lib/AST/DeclaratorDecl.cpp
@@ -33,8 +33,6 @@
 #include <multiplier/AST/VarTemplatePartialSpecializationDecl.h>
 #include <multiplier/AST/VarTemplateSpecializationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -119,17 +117,10 @@ bool DeclaratorDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DeclaratorDecl> DeclaratorDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DeclaratorDecl, ir::Operation>> DeclaratorDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kDeclaratorDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DeclaratorDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DeclaratorDecl> DeclaratorDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kDeclaratorDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/DecompositionDecl.cpp b/lib/AST/DecompositionDecl.cpp
index 2ae0a56a9..34e5a63a0 100644
--- a/lib/AST/DecompositionDecl.cpp
+++ b/lib/AST/DecompositionDecl.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -85,17 +83,10 @@ bool DecompositionDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DecompositionDecl> DecompositionDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DecompositionDecl, ir::Operation>> DecompositionDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kDecompositionDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DecompositionDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DecompositionDecl> DecompositionDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kDecompositionDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/DefaultStmt.cpp b/lib/AST/DefaultStmt.cpp
index 9fcfcb4e0..5d06d0a33 100644
--- a/lib/AST/DefaultStmt.cpp
+++ b/lib/AST/DefaultStmt.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/SwitchCase.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool DefaultStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DefaultStmt> DefaultStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DefaultStmt, ir::Operation>> DefaultStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kDefaultStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DefaultStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DefaultStmt> DefaultStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kDefaultStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/DependentCoawaitExpr.cpp b/lib/AST/DependentCoawaitExpr.cpp
index 1e3189f77..7d8a95308 100644
--- a/lib/AST/DependentCoawaitExpr.cpp
+++ b/lib/AST/DependentCoawaitExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/UnresolvedLookupExpr.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool DependentCoawaitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DependentCoawaitExpr> DependentCoawaitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DependentCoawaitExpr, ir::Operation>> DependentCoawaitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kDependentCoawaitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DependentCoawaitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DependentCoawaitExpr> DependentCoawaitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kDependentCoawaitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/DependentScopeDeclRefExpr.cpp b/lib/AST/DependentScopeDeclRefExpr.cpp
index 0bd208e8f..ce24c181a 100644
--- a/lib/AST/DependentScopeDeclRefExpr.cpp
+++ b/lib/AST/DependentScopeDeclRefExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool DependentScopeDeclRefExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DependentScopeDeclRefExpr> DependentScopeDeclRefExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DependentScopeDeclRefExpr, ir::Operation>> DependentScopeDeclRefExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kDependentScopeDeclRefExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DependentScopeDeclRefExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DependentScopeDeclRefExpr> DependentScopeDeclRefExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kDependentScopeDeclRefExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/DesignatedInitExpr.cpp b/lib/AST/DesignatedInitExpr.cpp
index 887a0da3b..3ea0f0572 100644
--- a/lib/AST/DesignatedInitExpr.cpp
+++ b/lib/AST/DesignatedInitExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Stmt.h"
@@ -84,17 +82,10 @@ bool DesignatedInitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DesignatedInitExpr> DesignatedInitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DesignatedInitExpr, ir::Operation>> DesignatedInitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kDesignatedInitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DesignatedInitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DesignatedInitExpr> DesignatedInitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kDesignatedInitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/DesignatedInitUpdateExpr.cpp b/lib/AST/DesignatedInitUpdateExpr.cpp
index fe9eee8f0..e23a5c535 100644
--- a/lib/AST/DesignatedInitUpdateExpr.cpp
+++ b/lib/AST/DesignatedInitUpdateExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool DesignatedInitUpdateExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DesignatedInitUpdateExpr> DesignatedInitUpdateExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DesignatedInitUpdateExpr, ir::Operation>> DesignatedInitUpdateExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kDesignatedInitUpdateExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DesignatedInitUpdateExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DesignatedInitUpdateExpr> DesignatedInitUpdateExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kDesignatedInitUpdateExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/DoStmt.cpp b/lib/AST/DoStmt.cpp
index 6dbb7c06e..3ba46d7d7 100644
--- a/lib/AST/DoStmt.cpp
+++ b/lib/AST/DoStmt.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool DoStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<DoStmt> DoStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<DoStmt, ir::Operation>> DoStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kDoStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<DoStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<DoStmt> DoStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kDoStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/EmptyDecl.cpp b/lib/AST/EmptyDecl.cpp
index a5bdaf79b..137234733 100644
--- a/lib/AST/EmptyDecl.cpp
+++ b/lib/AST/EmptyDecl.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -80,17 +78,10 @@ bool EmptyDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<EmptyDecl> EmptyDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<EmptyDecl, ir::Operation>> EmptyDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kEmptyDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<EmptyDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<EmptyDecl> EmptyDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kEmptyDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/EnumConstantDecl.cpp b/lib/AST/EnumConstantDecl.cpp
index 809a3353d..5dc6b73d7 100644
--- a/lib/AST/EnumConstantDecl.cpp
+++ b/lib/AST/EnumConstantDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool EnumConstantDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<EnumConstantDecl> EnumConstantDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<EnumConstantDecl, ir::Operation>> EnumConstantDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kEnumConstantDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<EnumConstantDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<EnumConstantDecl> EnumConstantDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kEnumConstantDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/EnumDecl.cpp b/lib/AST/EnumDecl.cpp
index ae5618fdb..196919964 100644
--- a/lib/AST/EnumDecl.cpp
+++ b/lib/AST/EnumDecl.cpp
@@ -17,8 +17,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/TypeDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -87,17 +85,10 @@ bool EnumDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<EnumDecl> EnumDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<EnumDecl, ir::Operation>> EnumDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kEnumDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<EnumDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<EnumDecl> EnumDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kEnumDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ExplicitCastExpr.cpp b/lib/AST/ExplicitCastExpr.cpp
index b46fc9d71..f9c10eb03 100644
--- a/lib/AST/ExplicitCastExpr.cpp
+++ b/lib/AST/ExplicitCastExpr.cpp
@@ -24,8 +24,6 @@
 #include <multiplier/AST/CXXStaticCastExpr.h>
 #include <multiplier/AST/ObjCBridgedCastExpr.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -101,17 +99,10 @@ bool ExplicitCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ExplicitCastExpr> ExplicitCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ExplicitCastExpr, ir::Operation>> ExplicitCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kExplicitCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ExplicitCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ExplicitCastExpr> ExplicitCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kExplicitCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ExportDecl.cpp b/lib/AST/ExportDecl.cpp
index 6ede346dc..8c4a3b667 100644
--- a/lib/AST/ExportDecl.cpp
+++ b/lib/AST/ExportDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool ExportDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ExportDecl> ExportDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ExportDecl, ir::Operation>> ExportDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kExportDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ExportDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ExportDecl> ExportDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kExportDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 75495e7c6..c0738c8f2 100644
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -139,8 +139,6 @@
 #include <multiplier/AST/UserDefinedLiteral.h>
 #include <multiplier/AST/VAArgExpr.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -331,17 +329,10 @@ bool Expr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<Expr> Expr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<Expr, ir::Operation>> Expr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<Expr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<Expr> Expr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ExprWithCleanups.cpp b/lib/AST/ExprWithCleanups.cpp
index 58a398b15..702f41024 100644
--- a/lib/AST/ExprWithCleanups.cpp
+++ b/lib/AST/ExprWithCleanups.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ExprWithCleanups::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ExprWithCleanups> ExprWithCleanups::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ExprWithCleanups, ir::Operation>> ExprWithCleanups::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kExprWithCleanupsDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ExprWithCleanups, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ExprWithCleanups> ExprWithCleanups::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kExprWithCleanupsDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ExpressionTraitExpr.cpp b/lib/AST/ExpressionTraitExpr.cpp
index e669baaed..83bee505c 100644
--- a/lib/AST/ExpressionTraitExpr.cpp
+++ b/lib/AST/ExpressionTraitExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ExpressionTraitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ExpressionTraitExpr> ExpressionTraitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ExpressionTraitExpr, ir::Operation>> ExpressionTraitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kExpressionTraitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ExpressionTraitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ExpressionTraitExpr> ExpressionTraitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kExpressionTraitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ExtVectorElementExpr.cpp b/lib/AST/ExtVectorElementExpr.cpp
index 730613d56..a543173d6 100644
--- a/lib/AST/ExtVectorElementExpr.cpp
+++ b/lib/AST/ExtVectorElementExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ExtVectorElementExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ExtVectorElementExpr> ExtVectorElementExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ExtVectorElementExpr, ir::Operation>> ExtVectorElementExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kExtVectorElementExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ExtVectorElementExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ExtVectorElementExpr> ExtVectorElementExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kExtVectorElementExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ExternCContextDecl.cpp b/lib/AST/ExternCContextDecl.cpp
index f13678c4b..00da32577 100644
--- a/lib/AST/ExternCContextDecl.cpp
+++ b/lib/AST/ExternCContextDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool ExternCContextDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ExternCContextDecl> ExternCContextDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ExternCContextDecl, ir::Operation>> ExternCContextDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kExternCContextDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ExternCContextDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ExternCContextDecl> ExternCContextDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kExternCContextDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FieldDecl.cpp b/lib/AST/FieldDecl.cpp
index 806659199..21fe1808f 100644
--- a/lib/AST/FieldDecl.cpp
+++ b/lib/AST/FieldDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/AST/ObjCAtDefsFieldDecl.h>
 #include <multiplier/AST/ObjCIvarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -89,17 +87,10 @@ bool FieldDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FieldDecl> FieldDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FieldDecl, ir::Operation>> FieldDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kFieldDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FieldDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FieldDecl> FieldDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kFieldDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FileScopeAsmDecl.cpp b/lib/AST/FileScopeAsmDecl.cpp
index a4c482de3..acc02b92d 100644
--- a/lib/AST/FileScopeAsmDecl.cpp
+++ b/lib/AST/FileScopeAsmDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/StringLiteral.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool FileScopeAsmDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FileScopeAsmDecl> FileScopeAsmDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FileScopeAsmDecl, ir::Operation>> FileScopeAsmDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kFileScopeAsmDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FileScopeAsmDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FileScopeAsmDecl> FileScopeAsmDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kFileScopeAsmDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FixedPointLiteral.cpp b/lib/AST/FixedPointLiteral.cpp
index 126632a6a..f5ad22846 100644
--- a/lib/AST/FixedPointLiteral.cpp
+++ b/lib/AST/FixedPointLiteral.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool FixedPointLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FixedPointLiteral> FixedPointLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FixedPointLiteral, ir::Operation>> FixedPointLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kFixedPointLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FixedPointLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FixedPointLiteral> FixedPointLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kFixedPointLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FloatingLiteral.cpp b/lib/AST/FloatingLiteral.cpp
index 797e9e90d..02c8a9b14 100644
--- a/lib/AST/FloatingLiteral.cpp
+++ b/lib/AST/FloatingLiteral.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool FloatingLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FloatingLiteral> FloatingLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FloatingLiteral, ir::Operation>> FloatingLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kFloatingLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FloatingLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FloatingLiteral> FloatingLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kFloatingLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ForStmt.cpp b/lib/AST/ForStmt.cpp
index 82c5fd139..2937abac8 100644
--- a/lib/AST/ForStmt.cpp
+++ b/lib/AST/ForStmt.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ForStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ForStmt> ForStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ForStmt, ir::Operation>> ForStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kForStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ForStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ForStmt> ForStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kForStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FriendDecl.cpp b/lib/AST/FriendDecl.cpp
index 206f97d38..0d40d9162 100644
--- a/lib/AST/FriendDecl.cpp
+++ b/lib/AST/FriendDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/Type.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool FriendDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FriendDecl> FriendDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FriendDecl, ir::Operation>> FriendDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kFriendDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FriendDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FriendDecl> FriendDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kFriendDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FriendTemplateDecl.cpp b/lib/AST/FriendTemplateDecl.cpp
index cd3badc7a..633055400 100644
--- a/lib/AST/FriendTemplateDecl.cpp
+++ b/lib/AST/FriendTemplateDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/Type.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool FriendTemplateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FriendTemplateDecl> FriendTemplateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FriendTemplateDecl, ir::Operation>> FriendTemplateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kFriendTemplateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FriendTemplateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FriendTemplateDecl> FriendTemplateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kFriendTemplateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FullExpr.cpp b/lib/AST/FullExpr.cpp
index b82f3a112..cc873e994 100644
--- a/lib/AST/FullExpr.cpp
+++ b/lib/AST/FullExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/ConstantExpr.h>
 #include <multiplier/AST/ExprWithCleanups.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -85,17 +83,10 @@ bool FullExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FullExpr> FullExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FullExpr, ir::Operation>> FullExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kFullExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FullExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FullExpr> FullExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kFullExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FunctionDecl.cpp b/lib/AST/FunctionDecl.cpp
index b9ef45a93..7e1747f13 100644
--- a/lib/AST/FunctionDecl.cpp
+++ b/lib/AST/FunctionDecl.cpp
@@ -24,8 +24,6 @@
 #include <multiplier/AST/CXXDestructorDecl.h>
 #include <multiplier/AST/CXXMethodDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -99,17 +97,10 @@ bool FunctionDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FunctionDecl> FunctionDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FunctionDecl, ir::Operation>> FunctionDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kFunctionDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FunctionDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FunctionDecl> FunctionDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kFunctionDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FunctionParmPackExpr.cpp b/lib/AST/FunctionParmPackExpr.cpp
index e222375b6..47fbb75b0 100644
--- a/lib/AST/FunctionParmPackExpr.cpp
+++ b/lib/AST/FunctionParmPackExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/ValueStmt.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool FunctionParmPackExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FunctionParmPackExpr> FunctionParmPackExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FunctionParmPackExpr, ir::Operation>> FunctionParmPackExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kFunctionParmPackExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FunctionParmPackExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FunctionParmPackExpr> FunctionParmPackExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kFunctionParmPackExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/FunctionTemplateDecl.cpp b/lib/AST/FunctionTemplateDecl.cpp
index 11f5a053b..271e59895 100644
--- a/lib/AST/FunctionTemplateDecl.cpp
+++ b/lib/AST/FunctionTemplateDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/TemplateDecl.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool FunctionTemplateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<FunctionTemplateDecl> FunctionTemplateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<FunctionTemplateDecl, ir::Operation>> FunctionTemplateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kFunctionTemplateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<FunctionTemplateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<FunctionTemplateDecl> FunctionTemplateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kFunctionTemplateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/GCCAsmStmt.cpp b/lib/AST/GCCAsmStmt.cpp
index 5478f2798..fbea5f10e 100644
--- a/lib/AST/GCCAsmStmt.cpp
+++ b/lib/AST/GCCAsmStmt.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/StringLiteral.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool GCCAsmStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<GCCAsmStmt> GCCAsmStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<GCCAsmStmt, ir::Operation>> GCCAsmStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kGCCAsmStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<GCCAsmStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<GCCAsmStmt> GCCAsmStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kGCCAsmStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/GNUNullExpr.cpp b/lib/AST/GNUNullExpr.cpp
index 8f881bac9..4bdb3c4a9 100644
--- a/lib/AST/GNUNullExpr.cpp
+++ b/lib/AST/GNUNullExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool GNUNullExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<GNUNullExpr> GNUNullExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<GNUNullExpr, ir::Operation>> GNUNullExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kGNUNullExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<GNUNullExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<GNUNullExpr> GNUNullExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kGNUNullExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/GenericSelectionExpr.cpp b/lib/AST/GenericSelectionExpr.cpp
index e93425634..4be9b2616 100644
--- a/lib/AST/GenericSelectionExpr.cpp
+++ b/lib/AST/GenericSelectionExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool GenericSelectionExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<GenericSelectionExpr> GenericSelectionExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<GenericSelectionExpr, ir::Operation>> GenericSelectionExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kGenericSelectionExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<GenericSelectionExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<GenericSelectionExpr> GenericSelectionExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kGenericSelectionExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/GotoStmt.cpp b/lib/AST/GotoStmt.cpp
index eecb8928d..03db9b894 100644
--- a/lib/AST/GotoStmt.cpp
+++ b/lib/AST/GotoStmt.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool GotoStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<GotoStmt> GotoStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<GotoStmt, ir::Operation>> GotoStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kGotoStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<GotoStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<GotoStmt> GotoStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kGotoStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/HLSLBufferDecl.cpp b/lib/AST/HLSLBufferDecl.cpp
index 98c4f8cef..73b5caf12 100644
--- a/lib/AST/HLSLBufferDecl.cpp
+++ b/lib/AST/HLSLBufferDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool HLSLBufferDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<HLSLBufferDecl> HLSLBufferDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<HLSLBufferDecl, ir::Operation>> HLSLBufferDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kHLSLBufferDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<HLSLBufferDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<HLSLBufferDecl> HLSLBufferDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kHLSLBufferDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/IfStmt.cpp b/lib/AST/IfStmt.cpp
index 2abb26569..bdd2f82cf 100644
--- a/lib/AST/IfStmt.cpp
+++ b/lib/AST/IfStmt.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool IfStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<IfStmt> IfStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<IfStmt, ir::Operation>> IfStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kIfStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<IfStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<IfStmt> IfStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kIfStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ImaginaryLiteral.cpp b/lib/AST/ImaginaryLiteral.cpp
index 081a3eb58..9c3b6cbbc 100644
--- a/lib/AST/ImaginaryLiteral.cpp
+++ b/lib/AST/ImaginaryLiteral.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ImaginaryLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ImaginaryLiteral> ImaginaryLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ImaginaryLiteral, ir::Operation>> ImaginaryLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kImaginaryLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ImaginaryLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ImaginaryLiteral> ImaginaryLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kImaginaryLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ImplicitCastExpr.cpp b/lib/AST/ImplicitCastExpr.cpp
index 665b53249..02cc0df6f 100644
--- a/lib/AST/ImplicitCastExpr.cpp
+++ b/lib/AST/ImplicitCastExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ImplicitCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ImplicitCastExpr> ImplicitCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ImplicitCastExpr, ir::Operation>> ImplicitCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kImplicitCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ImplicitCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ImplicitCastExpr> ImplicitCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kImplicitCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ImplicitConceptSpecializationDecl.cpp b/lib/AST/ImplicitConceptSpecializationDecl.cpp
index c9a1c589d..658365d10 100644
--- a/lib/AST/ImplicitConceptSpecializationDecl.cpp
+++ b/lib/AST/ImplicitConceptSpecializationDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/TemplateArgument.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool ImplicitConceptSpecializationDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ImplicitConceptSpecializationDecl> ImplicitConceptSpecializationDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ImplicitConceptSpecializationDecl, ir::Operation>> ImplicitConceptSpecializationDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kImplicitConceptSpecializationDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ImplicitConceptSpecializationDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ImplicitConceptSpecializationDecl> ImplicitConceptSpecializationDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kImplicitConceptSpecializationDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ImplicitParamDecl.cpp b/lib/AST/ImplicitParamDecl.cpp
index 5d3a20f6b..da66cd422 100644
--- a/lib/AST/ImplicitParamDecl.cpp
+++ b/lib/AST/ImplicitParamDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool ImplicitParamDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ImplicitParamDecl> ImplicitParamDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ImplicitParamDecl, ir::Operation>> ImplicitParamDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kImplicitParamDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ImplicitParamDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ImplicitParamDecl> ImplicitParamDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kImplicitParamDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ImplicitValueInitExpr.cpp b/lib/AST/ImplicitValueInitExpr.cpp
index 225953a99..f69927dd2 100644
--- a/lib/AST/ImplicitValueInitExpr.cpp
+++ b/lib/AST/ImplicitValueInitExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ImplicitValueInitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ImplicitValueInitExpr> ImplicitValueInitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ImplicitValueInitExpr, ir::Operation>> ImplicitValueInitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kImplicitValueInitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ImplicitValueInitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ImplicitValueInitExpr> ImplicitValueInitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kImplicitValueInitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ImportDecl.cpp b/lib/AST/ImportDecl.cpp
index f3315b51a..0622b6fa2 100644
--- a/lib/AST/ImportDecl.cpp
+++ b/lib/AST/ImportDecl.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -81,17 +79,10 @@ bool ImportDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ImportDecl> ImportDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ImportDecl, ir::Operation>> ImportDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kImportDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ImportDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ImportDecl> ImportDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kImportDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/IndirectFieldDecl.cpp b/lib/AST/IndirectFieldDecl.cpp
index 44643bd01..7314520ea 100644
--- a/lib/AST/IndirectFieldDecl.cpp
+++ b/lib/AST/IndirectFieldDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool IndirectFieldDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<IndirectFieldDecl> IndirectFieldDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<IndirectFieldDecl, ir::Operation>> IndirectFieldDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kIndirectFieldDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<IndirectFieldDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<IndirectFieldDecl> IndirectFieldDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kIndirectFieldDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/IndirectGotoStmt.cpp b/lib/AST/IndirectGotoStmt.cpp
index 5741cfdef..1beb3d898 100644
--- a/lib/AST/IndirectGotoStmt.cpp
+++ b/lib/AST/IndirectGotoStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool IndirectGotoStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<IndirectGotoStmt> IndirectGotoStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<IndirectGotoStmt, ir::Operation>> IndirectGotoStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kIndirectGotoStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<IndirectGotoStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<IndirectGotoStmt> IndirectGotoStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kIndirectGotoStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/InitListExpr.cpp b/lib/AST/InitListExpr.cpp
index dbaecf8b4..397f3dbdf 100644
--- a/lib/AST/InitListExpr.cpp
+++ b/lib/AST/InitListExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool InitListExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<InitListExpr> InitListExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<InitListExpr, ir::Operation>> InitListExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kInitListExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<InitListExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<InitListExpr> InitListExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kInitListExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/IntegerLiteral.cpp b/lib/AST/IntegerLiteral.cpp
index 8bc3f02ec..1a7569e3a 100644
--- a/lib/AST/IntegerLiteral.cpp
+++ b/lib/AST/IntegerLiteral.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool IntegerLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<IntegerLiteral> IntegerLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<IntegerLiteral, ir::Operation>> IntegerLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kIntegerLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<IntegerLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<IntegerLiteral> IntegerLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kIntegerLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/LabelDecl.cpp b/lib/AST/LabelDecl.cpp
index 78cddda27..a308a1c3c 100644
--- a/lib/AST/LabelDecl.cpp
+++ b/lib/AST/LabelDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool LabelDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<LabelDecl> LabelDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<LabelDecl, ir::Operation>> LabelDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kLabelDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<LabelDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<LabelDecl> LabelDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kLabelDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/LabelStmt.cpp b/lib/AST/LabelStmt.cpp
index 2aa1a83ab..a502a78e3 100644
--- a/lib/AST/LabelStmt.cpp
+++ b/lib/AST/LabelStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool LabelStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<LabelStmt> LabelStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<LabelStmt, ir::Operation>> LabelStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kLabelStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<LabelStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<LabelStmt> LabelStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kLabelStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/LambdaExpr.cpp b/lib/AST/LambdaExpr.cpp
index fa2703990..f3829ac6a 100644
--- a/lib/AST/LambdaExpr.cpp
+++ b/lib/AST/LambdaExpr.cpp
@@ -19,8 +19,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Stmt.h"
@@ -89,17 +87,10 @@ bool LambdaExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<LambdaExpr> LambdaExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<LambdaExpr, ir::Operation>> LambdaExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kLambdaExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<LambdaExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<LambdaExpr> LambdaExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kLambdaExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/LifetimeExtendedTemporaryDecl.cpp b/lib/AST/LifetimeExtendedTemporaryDecl.cpp
index 2b803df0d..b0caf2e37 100644
--- a/lib/AST/LifetimeExtendedTemporaryDecl.cpp
+++ b/lib/AST/LifetimeExtendedTemporaryDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool LifetimeExtendedTemporaryDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<LifetimeExtendedTemporaryDecl> LifetimeExtendedTemporaryDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<LifetimeExtendedTemporaryDecl, ir::Operation>> LifetimeExtendedTemporaryDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kLifetimeExtendedTemporaryDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<LifetimeExtendedTemporaryDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<LifetimeExtendedTemporaryDecl> LifetimeExtendedTemporaryDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kLifetimeExtendedTemporaryDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/LinkageSpecDecl.cpp b/lib/AST/LinkageSpecDecl.cpp
index 939e667d0..35325525f 100644
--- a/lib/AST/LinkageSpecDecl.cpp
+++ b/lib/AST/LinkageSpecDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool LinkageSpecDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<LinkageSpecDecl> LinkageSpecDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<LinkageSpecDecl, ir::Operation>> LinkageSpecDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kLinkageSpecDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<LinkageSpecDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<LinkageSpecDecl> LinkageSpecDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kLinkageSpecDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/MSAsmStmt.cpp b/lib/AST/MSAsmStmt.cpp
index d33800d13..2713ea8a6 100644
--- a/lib/AST/MSAsmStmt.cpp
+++ b/lib/AST/MSAsmStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool MSAsmStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<MSAsmStmt> MSAsmStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<MSAsmStmt, ir::Operation>> MSAsmStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kMSAsmStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<MSAsmStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<MSAsmStmt> MSAsmStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kMSAsmStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/MSDependentExistsStmt.cpp b/lib/AST/MSDependentExistsStmt.cpp
index 740ca8d33..c371deeac 100644
--- a/lib/AST/MSDependentExistsStmt.cpp
+++ b/lib/AST/MSDependentExistsStmt.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool MSDependentExistsStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<MSDependentExistsStmt> MSDependentExistsStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<MSDependentExistsStmt, ir::Operation>> MSDependentExistsStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kMSDependentExistsStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<MSDependentExistsStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<MSDependentExistsStmt> MSDependentExistsStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kMSDependentExistsStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/MSGuidDecl.cpp b/lib/AST/MSGuidDecl.cpp
index a5d59af00..c50d3a7a4 100644
--- a/lib/AST/MSGuidDecl.cpp
+++ b/lib/AST/MSGuidDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool MSGuidDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<MSGuidDecl> MSGuidDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<MSGuidDecl, ir::Operation>> MSGuidDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kMSGuidDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<MSGuidDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<MSGuidDecl> MSGuidDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kMSGuidDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/MSPropertyDecl.cpp b/lib/AST/MSPropertyDecl.cpp
index 1b1eb923b..3163a74ac 100644
--- a/lib/AST/MSPropertyDecl.cpp
+++ b/lib/AST/MSPropertyDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool MSPropertyDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<MSPropertyDecl> MSPropertyDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<MSPropertyDecl, ir::Operation>> MSPropertyDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kMSPropertyDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<MSPropertyDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<MSPropertyDecl> MSPropertyDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kMSPropertyDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/MSPropertyRefExpr.cpp b/lib/AST/MSPropertyRefExpr.cpp
index 486808a27..9897b447b 100644
--- a/lib/AST/MSPropertyRefExpr.cpp
+++ b/lib/AST/MSPropertyRefExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool MSPropertyRefExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<MSPropertyRefExpr> MSPropertyRefExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<MSPropertyRefExpr, ir::Operation>> MSPropertyRefExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kMSPropertyRefExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<MSPropertyRefExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<MSPropertyRefExpr> MSPropertyRefExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kMSPropertyRefExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/MSPropertySubscriptExpr.cpp b/lib/AST/MSPropertySubscriptExpr.cpp
index 6b3d0260c..808720108 100644
--- a/lib/AST/MSPropertySubscriptExpr.cpp
+++ b/lib/AST/MSPropertySubscriptExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool MSPropertySubscriptExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<MSPropertySubscriptExpr> MSPropertySubscriptExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<MSPropertySubscriptExpr, ir::Operation>> MSPropertySubscriptExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kMSPropertySubscriptExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<MSPropertySubscriptExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<MSPropertySubscriptExpr> MSPropertySubscriptExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kMSPropertySubscriptExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/MaterializeTemporaryExpr.cpp b/lib/AST/MaterializeTemporaryExpr.cpp
index 8865582ef..f9779db07 100644
--- a/lib/AST/MaterializeTemporaryExpr.cpp
+++ b/lib/AST/MaterializeTemporaryExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool MaterializeTemporaryExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<MaterializeTemporaryExpr> MaterializeTemporaryExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<MaterializeTemporaryExpr, ir::Operation>> MaterializeTemporaryExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kMaterializeTemporaryExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<MaterializeTemporaryExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<MaterializeTemporaryExpr> MaterializeTemporaryExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kMaterializeTemporaryExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/MatrixSubscriptExpr.cpp b/lib/AST/MatrixSubscriptExpr.cpp
index 1b3d9f73a..c7cf3cf50 100644
--- a/lib/AST/MatrixSubscriptExpr.cpp
+++ b/lib/AST/MatrixSubscriptExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool MatrixSubscriptExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<MatrixSubscriptExpr> MatrixSubscriptExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<MatrixSubscriptExpr, ir::Operation>> MatrixSubscriptExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kMatrixSubscriptExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<MatrixSubscriptExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<MatrixSubscriptExpr> MatrixSubscriptExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kMatrixSubscriptExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/MemberExpr.cpp b/lib/AST/MemberExpr.cpp
index b26c45cfc..32973ab15 100644
--- a/lib/AST/MemberExpr.cpp
+++ b/lib/AST/MemberExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool MemberExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<MemberExpr> MemberExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<MemberExpr, ir::Operation>> MemberExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kMemberExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<MemberExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<MemberExpr> MemberExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kMemberExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/NamedDecl.cpp b/lib/AST/NamedDecl.cpp
index 333787681..442f9d8b7 100644
--- a/lib/AST/NamedDecl.cpp
+++ b/lib/AST/NamedDecl.cpp
@@ -74,8 +74,6 @@
 #include <multiplier/AST/VarTemplatePartialSpecializationDecl.h>
 #include <multiplier/AST/VarTemplateSpecializationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -205,17 +203,10 @@ bool NamedDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<NamedDecl> NamedDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<NamedDecl, ir::Operation>> NamedDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kNamedDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<NamedDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<NamedDecl> NamedDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kNamedDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/NamespaceAliasDecl.cpp b/lib/AST/NamespaceAliasDecl.cpp
index fbfdc8651..52ecf641a 100644
--- a/lib/AST/NamespaceAliasDecl.cpp
+++ b/lib/AST/NamespaceAliasDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool NamespaceAliasDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<NamespaceAliasDecl> NamespaceAliasDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<NamespaceAliasDecl, ir::Operation>> NamespaceAliasDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kNamespaceAliasDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<NamespaceAliasDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<NamespaceAliasDecl> NamespaceAliasDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kNamespaceAliasDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/NamespaceDecl.cpp b/lib/AST/NamespaceDecl.cpp
index 76fb81779..7da4931f6 100644
--- a/lib/AST/NamespaceDecl.cpp
+++ b/lib/AST/NamespaceDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool NamespaceDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<NamespaceDecl> NamespaceDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<NamespaceDecl, ir::Operation>> NamespaceDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kNamespaceDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<NamespaceDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<NamespaceDecl> NamespaceDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kNamespaceDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/NoInitExpr.cpp b/lib/AST/NoInitExpr.cpp
index 7c5327eaa..12dd648d7 100644
--- a/lib/AST/NoInitExpr.cpp
+++ b/lib/AST/NoInitExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool NoInitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<NoInitExpr> NoInitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<NoInitExpr, ir::Operation>> NoInitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kNoInitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<NoInitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<NoInitExpr> NoInitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kNoInitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/NonTypeTemplateParmDecl.cpp b/lib/AST/NonTypeTemplateParmDecl.cpp
index eeaa45875..268cf393c 100644
--- a/lib/AST/NonTypeTemplateParmDecl.cpp
+++ b/lib/AST/NonTypeTemplateParmDecl.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -85,17 +83,10 @@ bool NonTypeTemplateParmDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<NonTypeTemplateParmDecl> NonTypeTemplateParmDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<NonTypeTemplateParmDecl, ir::Operation>> NonTypeTemplateParmDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kNonTypeTemplateParmDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<NonTypeTemplateParmDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<NonTypeTemplateParmDecl> NonTypeTemplateParmDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kNonTypeTemplateParmDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/NullStmt.cpp b/lib/AST/NullStmt.cpp
index fbb1157c5..8498842c7 100644
--- a/lib/AST/NullStmt.cpp
+++ b/lib/AST/NullStmt.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -80,17 +78,10 @@ bool NullStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<NullStmt> NullStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<NullStmt, ir::Operation>> NullStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kNullStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<NullStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<NullStmt> NullStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kNullStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPAllocateDecl.cpp b/lib/AST/OMPAllocateDecl.cpp
index e9eb32598..37b808845 100644
--- a/lib/AST/OMPAllocateDecl.cpp
+++ b/lib/AST/OMPAllocateDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool OMPAllocateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPAllocateDecl> OMPAllocateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPAllocateDecl, ir::Operation>> OMPAllocateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kOMPAllocateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPAllocateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPAllocateDecl> OMPAllocateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kOMPAllocateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPArraySectionExpr.cpp b/lib/AST/OMPArraySectionExpr.cpp
index c37882afd..38d6092f9 100644
--- a/lib/AST/OMPArraySectionExpr.cpp
+++ b/lib/AST/OMPArraySectionExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPArraySectionExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPArraySectionExpr> OMPArraySectionExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPArraySectionExpr, ir::Operation>> OMPArraySectionExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPArraySectionExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPArraySectionExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPArraySectionExpr> OMPArraySectionExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPArraySectionExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPArrayShapingExpr.cpp b/lib/AST/OMPArrayShapingExpr.cpp
index e316340a0..2d64a198b 100644
--- a/lib/AST/OMPArrayShapingExpr.cpp
+++ b/lib/AST/OMPArrayShapingExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPArrayShapingExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPArrayShapingExpr> OMPArrayShapingExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPArrayShapingExpr, ir::Operation>> OMPArrayShapingExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPArrayShapingExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPArrayShapingExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPArrayShapingExpr> OMPArrayShapingExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPArrayShapingExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPAtomicDirective.cpp b/lib/AST/OMPAtomicDirective.cpp
index 1c16ec018..e930504da 100644
--- a/lib/AST/OMPAtomicDirective.cpp
+++ b/lib/AST/OMPAtomicDirective.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPAtomicDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPAtomicDirective> OMPAtomicDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPAtomicDirective, ir::Operation>> OMPAtomicDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPAtomicDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPAtomicDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPAtomicDirective> OMPAtomicDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPAtomicDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPBarrierDirective.cpp b/lib/AST/OMPBarrierDirective.cpp
index 06f4c4ac8..704e59a71 100644
--- a/lib/AST/OMPBarrierDirective.cpp
+++ b/lib/AST/OMPBarrierDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPBarrierDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPBarrierDirective> OMPBarrierDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPBarrierDirective, ir::Operation>> OMPBarrierDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPBarrierDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPBarrierDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPBarrierDirective> OMPBarrierDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPBarrierDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPCancelDirective.cpp b/lib/AST/OMPCancelDirective.cpp
index 8047eac36..49ed777a6 100644
--- a/lib/AST/OMPCancelDirective.cpp
+++ b/lib/AST/OMPCancelDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPCancelDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPCancelDirective> OMPCancelDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPCancelDirective, ir::Operation>> OMPCancelDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPCancelDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPCancelDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPCancelDirective> OMPCancelDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPCancelDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPCancellationPointDirective.cpp b/lib/AST/OMPCancellationPointDirective.cpp
index 8596fdebd..ea53106c8 100644
--- a/lib/AST/OMPCancellationPointDirective.cpp
+++ b/lib/AST/OMPCancellationPointDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPCancellationPointDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPCancellationPointDirective> OMPCancellationPointDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPCancellationPointDirective, ir::Operation>> OMPCancellationPointDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPCancellationPointDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPCancellationPointDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPCancellationPointDirective> OMPCancellationPointDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPCancellationPointDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPCanonicalLoop.cpp b/lib/AST/OMPCanonicalLoop.cpp
index a272618b7..30f45c890 100644
--- a/lib/AST/OMPCanonicalLoop.cpp
+++ b/lib/AST/OMPCanonicalLoop.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPCanonicalLoop::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPCanonicalLoop> OMPCanonicalLoop::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPCanonicalLoop, ir::Operation>> OMPCanonicalLoop::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPCanonicalLoopDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPCanonicalLoop, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPCanonicalLoop> OMPCanonicalLoop::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPCanonicalLoopDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPCapturedExprDecl.cpp b/lib/AST/OMPCapturedExprDecl.cpp
index 944af41ea..3e961fc86 100644
--- a/lib/AST/OMPCapturedExprDecl.cpp
+++ b/lib/AST/OMPCapturedExprDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool OMPCapturedExprDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPCapturedExprDecl> OMPCapturedExprDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPCapturedExprDecl, ir::Operation>> OMPCapturedExprDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kOMPCapturedExprDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPCapturedExprDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPCapturedExprDecl> OMPCapturedExprDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kOMPCapturedExprDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPCriticalDirective.cpp b/lib/AST/OMPCriticalDirective.cpp
index ec887531a..d9da4a583 100644
--- a/lib/AST/OMPCriticalDirective.cpp
+++ b/lib/AST/OMPCriticalDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPCriticalDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPCriticalDirective> OMPCriticalDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPCriticalDirective, ir::Operation>> OMPCriticalDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPCriticalDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPCriticalDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPCriticalDirective> OMPCriticalDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPCriticalDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDeclarativeDirectiveDecl.cpp b/lib/AST/OMPDeclarativeDirectiveDecl.cpp
index 66b46cdcc..1cd7b796a 100644
--- a/lib/AST/OMPDeclarativeDirectiveDecl.cpp
+++ b/lib/AST/OMPDeclarativeDirectiveDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/OMPRequiresDecl.h>
 #include <multiplier/AST/OMPThreadPrivateDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -85,17 +83,10 @@ bool OMPDeclarativeDirectiveDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDeclarativeDirectiveDecl> OMPDeclarativeDirectiveDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDeclarativeDirectiveDecl, ir::Operation>> OMPDeclarativeDirectiveDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kOMPDeclarativeDirectiveDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDeclarativeDirectiveDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDeclarativeDirectiveDecl> OMPDeclarativeDirectiveDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kOMPDeclarativeDirectiveDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDeclarativeDirectiveValueDecl.cpp b/lib/AST/OMPDeclarativeDirectiveValueDecl.cpp
index 948d39bb7..9f8200d35 100644
--- a/lib/AST/OMPDeclarativeDirectiveValueDecl.cpp
+++ b/lib/AST/OMPDeclarativeDirectiveValueDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/OMPDeclareMapperDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool OMPDeclarativeDirectiveValueDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDeclarativeDirectiveValueDecl> OMPDeclarativeDirectiveValueDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDeclarativeDirectiveValueDecl, ir::Operation>> OMPDeclarativeDirectiveValueDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kOMPDeclarativeDirectiveValueDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDeclarativeDirectiveValueDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDeclarativeDirectiveValueDecl> OMPDeclarativeDirectiveValueDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kOMPDeclarativeDirectiveValueDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDeclareMapperDecl.cpp b/lib/AST/OMPDeclareMapperDecl.cpp
index 5030d474a..40a8f781a 100644
--- a/lib/AST/OMPDeclareMapperDecl.cpp
+++ b/lib/AST/OMPDeclareMapperDecl.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -85,17 +83,10 @@ bool OMPDeclareMapperDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDeclareMapperDecl> OMPDeclareMapperDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDeclareMapperDecl, ir::Operation>> OMPDeclareMapperDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kOMPDeclareMapperDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDeclareMapperDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDeclareMapperDecl> OMPDeclareMapperDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kOMPDeclareMapperDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDeclareReductionDecl.cpp b/lib/AST/OMPDeclareReductionDecl.cpp
index 8c9311891..9c42d1d15 100644
--- a/lib/AST/OMPDeclareReductionDecl.cpp
+++ b/lib/AST/OMPDeclareReductionDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool OMPDeclareReductionDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDeclareReductionDecl> OMPDeclareReductionDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDeclareReductionDecl, ir::Operation>> OMPDeclareReductionDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kOMPDeclareReductionDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDeclareReductionDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDeclareReductionDecl> OMPDeclareReductionDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kOMPDeclareReductionDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDepobjDirective.cpp b/lib/AST/OMPDepobjDirective.cpp
index 79c0f7c44..fc1e62299 100644
--- a/lib/AST/OMPDepobjDirective.cpp
+++ b/lib/AST/OMPDepobjDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPDepobjDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDepobjDirective> OMPDepobjDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDepobjDirective, ir::Operation>> OMPDepobjDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPDepobjDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDepobjDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDepobjDirective> OMPDepobjDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPDepobjDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDispatchDirective.cpp b/lib/AST/OMPDispatchDirective.cpp
index c027fbc92..c574ae679 100644
--- a/lib/AST/OMPDispatchDirective.cpp
+++ b/lib/AST/OMPDispatchDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPDispatchDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDispatchDirective> OMPDispatchDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDispatchDirective, ir::Operation>> OMPDispatchDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPDispatchDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDispatchDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDispatchDirective> OMPDispatchDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPDispatchDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDistributeDirective.cpp b/lib/AST/OMPDistributeDirective.cpp
index 2b908441d..3dee12ac0 100644
--- a/lib/AST/OMPDistributeDirective.cpp
+++ b/lib/AST/OMPDistributeDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPDistributeDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDistributeDirective> OMPDistributeDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDistributeDirective, ir::Operation>> OMPDistributeDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPDistributeDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDistributeDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDistributeDirective> OMPDistributeDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPDistributeDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDistributeParallelForDirective.cpp b/lib/AST/OMPDistributeParallelForDirective.cpp
index 523c8cdcb..9d70c5e14 100644
--- a/lib/AST/OMPDistributeParallelForDirective.cpp
+++ b/lib/AST/OMPDistributeParallelForDirective.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool OMPDistributeParallelForDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDistributeParallelForDirective> OMPDistributeParallelForDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDistributeParallelForDirective, ir::Operation>> OMPDistributeParallelForDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPDistributeParallelForDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDistributeParallelForDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDistributeParallelForDirective> OMPDistributeParallelForDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPDistributeParallelForDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDistributeParallelForSimdDirective.cpp b/lib/AST/OMPDistributeParallelForSimdDirective.cpp
index b45f99a86..9df8e7d82 100644
--- a/lib/AST/OMPDistributeParallelForSimdDirective.cpp
+++ b/lib/AST/OMPDistributeParallelForSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPDistributeParallelForSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDistributeParallelForSimdDirective> OMPDistributeParallelForSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDistributeParallelForSimdDirective, ir::Operation>> OMPDistributeParallelForSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPDistributeParallelForSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDistributeParallelForSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDistributeParallelForSimdDirective> OMPDistributeParallelForSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPDistributeParallelForSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPDistributeSimdDirective.cpp b/lib/AST/OMPDistributeSimdDirective.cpp
index eda042659..02522f4dc 100644
--- a/lib/AST/OMPDistributeSimdDirective.cpp
+++ b/lib/AST/OMPDistributeSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPDistributeSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPDistributeSimdDirective> OMPDistributeSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPDistributeSimdDirective, ir::Operation>> OMPDistributeSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPDistributeSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPDistributeSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPDistributeSimdDirective> OMPDistributeSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPDistributeSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPErrorDirective.cpp b/lib/AST/OMPErrorDirective.cpp
index 3807a2bbc..0c154eb64 100644
--- a/lib/AST/OMPErrorDirective.cpp
+++ b/lib/AST/OMPErrorDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPErrorDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPErrorDirective> OMPErrorDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPErrorDirective, ir::Operation>> OMPErrorDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPErrorDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPErrorDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPErrorDirective> OMPErrorDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPErrorDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPExecutableDirective.cpp b/lib/AST/OMPExecutableDirective.cpp
index 36182f552..07aae749f 100644
--- a/lib/AST/OMPExecutableDirective.cpp
+++ b/lib/AST/OMPExecutableDirective.cpp
@@ -84,8 +84,6 @@
 #include <multiplier/AST/OMPTileDirective.h>
 #include <multiplier/AST/OMPUnrollDirective.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -224,17 +222,10 @@ bool OMPExecutableDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPExecutableDirective> OMPExecutableDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPExecutableDirective, ir::Operation>> OMPExecutableDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPExecutableDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPExecutableDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPExecutableDirective> OMPExecutableDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPExecutableDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPFlushDirective.cpp b/lib/AST/OMPFlushDirective.cpp
index c7c4da96c..1c4b376ad 100644
--- a/lib/AST/OMPFlushDirective.cpp
+++ b/lib/AST/OMPFlushDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPFlushDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPFlushDirective> OMPFlushDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPFlushDirective, ir::Operation>> OMPFlushDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPFlushDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPFlushDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPFlushDirective> OMPFlushDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPFlushDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPForDirective.cpp b/lib/AST/OMPForDirective.cpp
index 0951410c7..459ef5049 100644
--- a/lib/AST/OMPForDirective.cpp
+++ b/lib/AST/OMPForDirective.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool OMPForDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPForDirective> OMPForDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPForDirective, ir::Operation>> OMPForDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPForDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPForDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPForDirective> OMPForDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPForDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPForSimdDirective.cpp b/lib/AST/OMPForSimdDirective.cpp
index fca3533a2..8cbb42ba5 100644
--- a/lib/AST/OMPForSimdDirective.cpp
+++ b/lib/AST/OMPForSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPForSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPForSimdDirective> OMPForSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPForSimdDirective, ir::Operation>> OMPForSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPForSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPForSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPForSimdDirective> OMPForSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPForSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPGenericLoopDirective.cpp b/lib/AST/OMPGenericLoopDirective.cpp
index 631fca684..ec9134a38 100644
--- a/lib/AST/OMPGenericLoopDirective.cpp
+++ b/lib/AST/OMPGenericLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPGenericLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPGenericLoopDirective> OMPGenericLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPGenericLoopDirective, ir::Operation>> OMPGenericLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPGenericLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPGenericLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPGenericLoopDirective> OMPGenericLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPGenericLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPInteropDirective.cpp b/lib/AST/OMPInteropDirective.cpp
index af2ac19e7..eadf9d1fc 100644
--- a/lib/AST/OMPInteropDirective.cpp
+++ b/lib/AST/OMPInteropDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPInteropDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPInteropDirective> OMPInteropDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPInteropDirective, ir::Operation>> OMPInteropDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPInteropDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPInteropDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPInteropDirective> OMPInteropDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPInteropDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPIteratorExpr.cpp b/lib/AST/OMPIteratorExpr.cpp
index ed27c5514..5df9510fd 100644
--- a/lib/AST/OMPIteratorExpr.cpp
+++ b/lib/AST/OMPIteratorExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPIteratorExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPIteratorExpr> OMPIteratorExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPIteratorExpr, ir::Operation>> OMPIteratorExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPIteratorExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPIteratorExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPIteratorExpr> OMPIteratorExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPIteratorExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPLoopBasedDirective.cpp b/lib/AST/OMPLoopBasedDirective.cpp
index d72d965ef..96e5511c0 100644
--- a/lib/AST/OMPLoopBasedDirective.cpp
+++ b/lib/AST/OMPLoopBasedDirective.cpp
@@ -49,8 +49,6 @@
 #include <multiplier/AST/OMPTileDirective.h>
 #include <multiplier/AST/OMPUnrollDirective.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -154,17 +152,10 @@ bool OMPLoopBasedDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPLoopBasedDirective> OMPLoopBasedDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPLoopBasedDirective, ir::Operation>> OMPLoopBasedDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPLoopBasedDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPLoopBasedDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPLoopBasedDirective> OMPLoopBasedDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPLoopBasedDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPLoopDirective.cpp b/lib/AST/OMPLoopDirective.cpp
index 64bbb7622..0dc0318ab 100644
--- a/lib/AST/OMPLoopDirective.cpp
+++ b/lib/AST/OMPLoopDirective.cpp
@@ -49,8 +49,6 @@
 #include <multiplier/AST/OMPTeamsDistributeSimdDirective.h>
 #include <multiplier/AST/OMPTeamsGenericLoopDirective.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -152,17 +150,10 @@ bool OMPLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPLoopDirective> OMPLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPLoopDirective, ir::Operation>> OMPLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPLoopDirective> OMPLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPLoopTransformationDirective.cpp b/lib/AST/OMPLoopTransformationDirective.cpp
index 15c6d2f57..ab4ed33f5 100644
--- a/lib/AST/OMPLoopTransformationDirective.cpp
+++ b/lib/AST/OMPLoopTransformationDirective.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/OMPTileDirective.h>
 #include <multiplier/AST/OMPUnrollDirective.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -85,17 +83,10 @@ bool OMPLoopTransformationDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPLoopTransformationDirective> OMPLoopTransformationDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPLoopTransformationDirective, ir::Operation>> OMPLoopTransformationDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPLoopTransformationDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPLoopTransformationDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPLoopTransformationDirective> OMPLoopTransformationDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPLoopTransformationDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPMaskedDirective.cpp b/lib/AST/OMPMaskedDirective.cpp
index 585aa43a0..ad95d345e 100644
--- a/lib/AST/OMPMaskedDirective.cpp
+++ b/lib/AST/OMPMaskedDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPMaskedDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPMaskedDirective> OMPMaskedDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPMaskedDirective, ir::Operation>> OMPMaskedDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPMaskedDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPMaskedDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPMaskedDirective> OMPMaskedDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPMaskedDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPMaskedTaskLoopDirective.cpp b/lib/AST/OMPMaskedTaskLoopDirective.cpp
index cf6f52a46..d0d4cd378 100644
--- a/lib/AST/OMPMaskedTaskLoopDirective.cpp
+++ b/lib/AST/OMPMaskedTaskLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPMaskedTaskLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPMaskedTaskLoopDirective> OMPMaskedTaskLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPMaskedTaskLoopDirective, ir::Operation>> OMPMaskedTaskLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPMaskedTaskLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPMaskedTaskLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPMaskedTaskLoopDirective> OMPMaskedTaskLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPMaskedTaskLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPMaskedTaskLoopSimdDirective.cpp b/lib/AST/OMPMaskedTaskLoopSimdDirective.cpp
index 3f5281d50..2a4b5e7dc 100644
--- a/lib/AST/OMPMaskedTaskLoopSimdDirective.cpp
+++ b/lib/AST/OMPMaskedTaskLoopSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPMaskedTaskLoopSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPMaskedTaskLoopSimdDirective> OMPMaskedTaskLoopSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPMaskedTaskLoopSimdDirective, ir::Operation>> OMPMaskedTaskLoopSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPMaskedTaskLoopSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPMaskedTaskLoopSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPMaskedTaskLoopSimdDirective> OMPMaskedTaskLoopSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPMaskedTaskLoopSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPMasterDirective.cpp b/lib/AST/OMPMasterDirective.cpp
index 255fe57e9..bf86b2b57 100644
--- a/lib/AST/OMPMasterDirective.cpp
+++ b/lib/AST/OMPMasterDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPMasterDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPMasterDirective> OMPMasterDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPMasterDirective, ir::Operation>> OMPMasterDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPMasterDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPMasterDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPMasterDirective> OMPMasterDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPMasterDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPMasterTaskLoopDirective.cpp b/lib/AST/OMPMasterTaskLoopDirective.cpp
index f33af37b1..5a55f1dbe 100644
--- a/lib/AST/OMPMasterTaskLoopDirective.cpp
+++ b/lib/AST/OMPMasterTaskLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPMasterTaskLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPMasterTaskLoopDirective> OMPMasterTaskLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPMasterTaskLoopDirective, ir::Operation>> OMPMasterTaskLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPMasterTaskLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPMasterTaskLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPMasterTaskLoopDirective> OMPMasterTaskLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPMasterTaskLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPMasterTaskLoopSimdDirective.cpp b/lib/AST/OMPMasterTaskLoopSimdDirective.cpp
index 05c99546b..7f22c2ef4 100644
--- a/lib/AST/OMPMasterTaskLoopSimdDirective.cpp
+++ b/lib/AST/OMPMasterTaskLoopSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPMasterTaskLoopSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPMasterTaskLoopSimdDirective> OMPMasterTaskLoopSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPMasterTaskLoopSimdDirective, ir::Operation>> OMPMasterTaskLoopSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPMasterTaskLoopSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPMasterTaskLoopSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPMasterTaskLoopSimdDirective> OMPMasterTaskLoopSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPMasterTaskLoopSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPMetaDirective.cpp b/lib/AST/OMPMetaDirective.cpp
index e5f4c8be2..9e11ef047 100644
--- a/lib/AST/OMPMetaDirective.cpp
+++ b/lib/AST/OMPMetaDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPMetaDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPMetaDirective> OMPMetaDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPMetaDirective, ir::Operation>> OMPMetaDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPMetaDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPMetaDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPMetaDirective> OMPMetaDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPMetaDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPOrderedDirective.cpp b/lib/AST/OMPOrderedDirective.cpp
index 000d9c884..d2fc6daaf 100644
--- a/lib/AST/OMPOrderedDirective.cpp
+++ b/lib/AST/OMPOrderedDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPOrderedDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPOrderedDirective> OMPOrderedDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPOrderedDirective, ir::Operation>> OMPOrderedDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPOrderedDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPOrderedDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPOrderedDirective> OMPOrderedDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPOrderedDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelDirective.cpp b/lib/AST/OMPParallelDirective.cpp
index a52235c00..bc2c47c5f 100644
--- a/lib/AST/OMPParallelDirective.cpp
+++ b/lib/AST/OMPParallelDirective.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPParallelDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelDirective> OMPParallelDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelDirective, ir::Operation>> OMPParallelDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelDirective> OMPParallelDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelForDirective.cpp b/lib/AST/OMPParallelForDirective.cpp
index 3b1f5ac22..b15b5aa5e 100644
--- a/lib/AST/OMPParallelForDirective.cpp
+++ b/lib/AST/OMPParallelForDirective.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool OMPParallelForDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelForDirective> OMPParallelForDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelForDirective, ir::Operation>> OMPParallelForDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelForDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelForDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelForDirective> OMPParallelForDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelForDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelForSimdDirective.cpp b/lib/AST/OMPParallelForSimdDirective.cpp
index 0351dea26..8a85f654f 100644
--- a/lib/AST/OMPParallelForSimdDirective.cpp
+++ b/lib/AST/OMPParallelForSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPParallelForSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelForSimdDirective> OMPParallelForSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelForSimdDirective, ir::Operation>> OMPParallelForSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelForSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelForSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelForSimdDirective> OMPParallelForSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelForSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelGenericLoopDirective.cpp b/lib/AST/OMPParallelGenericLoopDirective.cpp
index f91d134c9..385bcfe95 100644
--- a/lib/AST/OMPParallelGenericLoopDirective.cpp
+++ b/lib/AST/OMPParallelGenericLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPParallelGenericLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelGenericLoopDirective> OMPParallelGenericLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelGenericLoopDirective, ir::Operation>> OMPParallelGenericLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelGenericLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelGenericLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelGenericLoopDirective> OMPParallelGenericLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelGenericLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelMaskedDirective.cpp b/lib/AST/OMPParallelMaskedDirective.cpp
index b0f0228b8..9dc44c618 100644
--- a/lib/AST/OMPParallelMaskedDirective.cpp
+++ b/lib/AST/OMPParallelMaskedDirective.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPParallelMaskedDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelMaskedDirective> OMPParallelMaskedDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelMaskedDirective, ir::Operation>> OMPParallelMaskedDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelMaskedDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelMaskedDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelMaskedDirective> OMPParallelMaskedDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelMaskedDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelMaskedTaskLoopDirective.cpp b/lib/AST/OMPParallelMaskedTaskLoopDirective.cpp
index 24cd60c6f..95a33bc32 100644
--- a/lib/AST/OMPParallelMaskedTaskLoopDirective.cpp
+++ b/lib/AST/OMPParallelMaskedTaskLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPParallelMaskedTaskLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelMaskedTaskLoopDirective> OMPParallelMaskedTaskLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelMaskedTaskLoopDirective, ir::Operation>> OMPParallelMaskedTaskLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelMaskedTaskLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelMaskedTaskLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelMaskedTaskLoopDirective> OMPParallelMaskedTaskLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelMaskedTaskLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp b/lib/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp
index fae19c5ef..cb1053cb1 100644
--- a/lib/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp
+++ b/lib/AST/OMPParallelMaskedTaskLoopSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPParallelMaskedTaskLoopSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelMaskedTaskLoopSimdDirective> OMPParallelMaskedTaskLoopSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelMaskedTaskLoopSimdDirective, ir::Operation>> OMPParallelMaskedTaskLoopSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelMaskedTaskLoopSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelMaskedTaskLoopSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelMaskedTaskLoopSimdDirective> OMPParallelMaskedTaskLoopSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelMaskedTaskLoopSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelMasterDirective.cpp b/lib/AST/OMPParallelMasterDirective.cpp
index df830f0c8..eab99b171 100644
--- a/lib/AST/OMPParallelMasterDirective.cpp
+++ b/lib/AST/OMPParallelMasterDirective.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPParallelMasterDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelMasterDirective> OMPParallelMasterDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelMasterDirective, ir::Operation>> OMPParallelMasterDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelMasterDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelMasterDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelMasterDirective> OMPParallelMasterDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelMasterDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelMasterTaskLoopDirective.cpp b/lib/AST/OMPParallelMasterTaskLoopDirective.cpp
index 5aa8360a4..7a3a73c3b 100644
--- a/lib/AST/OMPParallelMasterTaskLoopDirective.cpp
+++ b/lib/AST/OMPParallelMasterTaskLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPParallelMasterTaskLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelMasterTaskLoopDirective> OMPParallelMasterTaskLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelMasterTaskLoopDirective, ir::Operation>> OMPParallelMasterTaskLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelMasterTaskLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelMasterTaskLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelMasterTaskLoopDirective> OMPParallelMasterTaskLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelMasterTaskLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelMasterTaskLoopSimdDirective.cpp b/lib/AST/OMPParallelMasterTaskLoopSimdDirective.cpp
index 73625e3f2..6c753eb6e 100644
--- a/lib/AST/OMPParallelMasterTaskLoopSimdDirective.cpp
+++ b/lib/AST/OMPParallelMasterTaskLoopSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPParallelMasterTaskLoopSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelMasterTaskLoopSimdDirective> OMPParallelMasterTaskLoopSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelMasterTaskLoopSimdDirective, ir::Operation>> OMPParallelMasterTaskLoopSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelMasterTaskLoopSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelMasterTaskLoopSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelMasterTaskLoopSimdDirective> OMPParallelMasterTaskLoopSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelMasterTaskLoopSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPParallelSectionsDirective.cpp b/lib/AST/OMPParallelSectionsDirective.cpp
index 1c5c0fb86..42769be3d 100644
--- a/lib/AST/OMPParallelSectionsDirective.cpp
+++ b/lib/AST/OMPParallelSectionsDirective.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPParallelSectionsDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPParallelSectionsDirective> OMPParallelSectionsDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPParallelSectionsDirective, ir::Operation>> OMPParallelSectionsDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPParallelSectionsDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPParallelSectionsDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPParallelSectionsDirective> OMPParallelSectionsDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPParallelSectionsDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPRequiresDecl.cpp b/lib/AST/OMPRequiresDecl.cpp
index 1eccf16b8..02c645e73 100644
--- a/lib/AST/OMPRequiresDecl.cpp
+++ b/lib/AST/OMPRequiresDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool OMPRequiresDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPRequiresDecl> OMPRequiresDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPRequiresDecl, ir::Operation>> OMPRequiresDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kOMPRequiresDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPRequiresDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPRequiresDecl> OMPRequiresDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kOMPRequiresDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPScanDirective.cpp b/lib/AST/OMPScanDirective.cpp
index 472226592..8d7af1d40 100644
--- a/lib/AST/OMPScanDirective.cpp
+++ b/lib/AST/OMPScanDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPScanDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPScanDirective> OMPScanDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPScanDirective, ir::Operation>> OMPScanDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPScanDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPScanDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPScanDirective> OMPScanDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPScanDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPScopeDirective.cpp b/lib/AST/OMPScopeDirective.cpp
index 9ce6c70f3..79b82dcc0 100644
--- a/lib/AST/OMPScopeDirective.cpp
+++ b/lib/AST/OMPScopeDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPScopeDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPScopeDirective> OMPScopeDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPScopeDirective, ir::Operation>> OMPScopeDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPScopeDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPScopeDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPScopeDirective> OMPScopeDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPScopeDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPSectionDirective.cpp b/lib/AST/OMPSectionDirective.cpp
index 91a6546a3..79dfb28b5 100644
--- a/lib/AST/OMPSectionDirective.cpp
+++ b/lib/AST/OMPSectionDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPSectionDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPSectionDirective> OMPSectionDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPSectionDirective, ir::Operation>> OMPSectionDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPSectionDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPSectionDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPSectionDirective> OMPSectionDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPSectionDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPSectionsDirective.cpp b/lib/AST/OMPSectionsDirective.cpp
index d1c001c4b..d24ec0978 100644
--- a/lib/AST/OMPSectionsDirective.cpp
+++ b/lib/AST/OMPSectionsDirective.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPSectionsDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPSectionsDirective> OMPSectionsDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPSectionsDirective, ir::Operation>> OMPSectionsDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPSectionsDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPSectionsDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPSectionsDirective> OMPSectionsDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPSectionsDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPSimdDirective.cpp b/lib/AST/OMPSimdDirective.cpp
index ddfc12e81..1484d6c53 100644
--- a/lib/AST/OMPSimdDirective.cpp
+++ b/lib/AST/OMPSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPSimdDirective> OMPSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPSimdDirective, ir::Operation>> OMPSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPSimdDirective> OMPSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPSingleDirective.cpp b/lib/AST/OMPSingleDirective.cpp
index 8dbcf1139..883fda6a8 100644
--- a/lib/AST/OMPSingleDirective.cpp
+++ b/lib/AST/OMPSingleDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPSingleDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPSingleDirective> OMPSingleDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPSingleDirective, ir::Operation>> OMPSingleDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPSingleDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPSingleDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPSingleDirective> OMPSingleDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPSingleDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetDataDirective.cpp b/lib/AST/OMPTargetDataDirective.cpp
index 59f8583c5..5e7c82ac8 100644
--- a/lib/AST/OMPTargetDataDirective.cpp
+++ b/lib/AST/OMPTargetDataDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTargetDataDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetDataDirective> OMPTargetDataDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetDataDirective, ir::Operation>> OMPTargetDataDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetDataDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetDataDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetDataDirective> OMPTargetDataDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetDataDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetDirective.cpp b/lib/AST/OMPTargetDirective.cpp
index 0070af380..37cd02b31 100644
--- a/lib/AST/OMPTargetDirective.cpp
+++ b/lib/AST/OMPTargetDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTargetDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetDirective> OMPTargetDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetDirective, ir::Operation>> OMPTargetDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetDirective> OMPTargetDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetEnterDataDirective.cpp b/lib/AST/OMPTargetEnterDataDirective.cpp
index 27a3646de..eabaa5149 100644
--- a/lib/AST/OMPTargetEnterDataDirective.cpp
+++ b/lib/AST/OMPTargetEnterDataDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTargetEnterDataDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetEnterDataDirective> OMPTargetEnterDataDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetEnterDataDirective, ir::Operation>> OMPTargetEnterDataDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetEnterDataDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetEnterDataDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetEnterDataDirective> OMPTargetEnterDataDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetEnterDataDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetExitDataDirective.cpp b/lib/AST/OMPTargetExitDataDirective.cpp
index 522dcef04..ed5d4d2da 100644
--- a/lib/AST/OMPTargetExitDataDirective.cpp
+++ b/lib/AST/OMPTargetExitDataDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTargetExitDataDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetExitDataDirective> OMPTargetExitDataDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetExitDataDirective, ir::Operation>> OMPTargetExitDataDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetExitDataDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetExitDataDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetExitDataDirective> OMPTargetExitDataDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetExitDataDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetParallelDirective.cpp b/lib/AST/OMPTargetParallelDirective.cpp
index 0f8bdb1c8..353e42460 100644
--- a/lib/AST/OMPTargetParallelDirective.cpp
+++ b/lib/AST/OMPTargetParallelDirective.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPTargetParallelDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetParallelDirective> OMPTargetParallelDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetParallelDirective, ir::Operation>> OMPTargetParallelDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetParallelDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetParallelDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetParallelDirective> OMPTargetParallelDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetParallelDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetParallelForDirective.cpp b/lib/AST/OMPTargetParallelForDirective.cpp
index 0ba53d653..e45ba4418 100644
--- a/lib/AST/OMPTargetParallelForDirective.cpp
+++ b/lib/AST/OMPTargetParallelForDirective.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool OMPTargetParallelForDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetParallelForDirective> OMPTargetParallelForDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetParallelForDirective, ir::Operation>> OMPTargetParallelForDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetParallelForDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetParallelForDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetParallelForDirective> OMPTargetParallelForDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetParallelForDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetParallelForSimdDirective.cpp b/lib/AST/OMPTargetParallelForSimdDirective.cpp
index 217c25433..15421f256 100644
--- a/lib/AST/OMPTargetParallelForSimdDirective.cpp
+++ b/lib/AST/OMPTargetParallelForSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTargetParallelForSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetParallelForSimdDirective> OMPTargetParallelForSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetParallelForSimdDirective, ir::Operation>> OMPTargetParallelForSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetParallelForSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetParallelForSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetParallelForSimdDirective> OMPTargetParallelForSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetParallelForSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetParallelGenericLoopDirective.cpp b/lib/AST/OMPTargetParallelGenericLoopDirective.cpp
index b38116ae1..6d0107308 100644
--- a/lib/AST/OMPTargetParallelGenericLoopDirective.cpp
+++ b/lib/AST/OMPTargetParallelGenericLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTargetParallelGenericLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetParallelGenericLoopDirective> OMPTargetParallelGenericLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetParallelGenericLoopDirective, ir::Operation>> OMPTargetParallelGenericLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetParallelGenericLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetParallelGenericLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetParallelGenericLoopDirective> OMPTargetParallelGenericLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetParallelGenericLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetSimdDirective.cpp b/lib/AST/OMPTargetSimdDirective.cpp
index 41ccf682d..2d5b8efce 100644
--- a/lib/AST/OMPTargetSimdDirective.cpp
+++ b/lib/AST/OMPTargetSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTargetSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetSimdDirective> OMPTargetSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetSimdDirective, ir::Operation>> OMPTargetSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetSimdDirective> OMPTargetSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetTeamsDirective.cpp b/lib/AST/OMPTargetTeamsDirective.cpp
index fa94f03c3..91f86e9c7 100644
--- a/lib/AST/OMPTargetTeamsDirective.cpp
+++ b/lib/AST/OMPTargetTeamsDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTargetTeamsDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetTeamsDirective> OMPTargetTeamsDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetTeamsDirective, ir::Operation>> OMPTargetTeamsDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetTeamsDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetTeamsDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetTeamsDirective> OMPTargetTeamsDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetTeamsDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetTeamsDistributeDirective.cpp b/lib/AST/OMPTargetTeamsDistributeDirective.cpp
index db045b130..1da434623 100644
--- a/lib/AST/OMPTargetTeamsDistributeDirective.cpp
+++ b/lib/AST/OMPTargetTeamsDistributeDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTargetTeamsDistributeDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetTeamsDistributeDirective> OMPTargetTeamsDistributeDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetTeamsDistributeDirective, ir::Operation>> OMPTargetTeamsDistributeDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetTeamsDistributeDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetTeamsDistributeDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetTeamsDistributeDirective> OMPTargetTeamsDistributeDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetTeamsDistributeDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetTeamsDistributeParallelForDirective.cpp b/lib/AST/OMPTargetTeamsDistributeParallelForDirective.cpp
index 4f20de905..2c87ba9d5 100644
--- a/lib/AST/OMPTargetTeamsDistributeParallelForDirective.cpp
+++ b/lib/AST/OMPTargetTeamsDistributeParallelForDirective.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool OMPTargetTeamsDistributeParallelForDirective::contains(const Token &tok) co
   return false;
 }
 
-std::optional<OMPTargetTeamsDistributeParallelForDirective> OMPTargetTeamsDistributeParallelForDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetTeamsDistributeParallelForDirective, ir::Operation>> OMPTargetTeamsDistributeParallelForDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetTeamsDistributeParallelForDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetTeamsDistributeParallelForDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetTeamsDistributeParallelForDirective> OMPTargetTeamsDistributeParallelForDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetTeamsDistributeParallelForDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp b/lib/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp
index 52cf4d62f..2345da5d3 100644
--- a/lib/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp
+++ b/lib/AST/OMPTargetTeamsDistributeParallelForSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTargetTeamsDistributeParallelForSimdDirective::contains(const Token &tok
   return false;
 }
 
-std::optional<OMPTargetTeamsDistributeParallelForSimdDirective> OMPTargetTeamsDistributeParallelForSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetTeamsDistributeParallelForSimdDirective, ir::Operation>> OMPTargetTeamsDistributeParallelForSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetTeamsDistributeParallelForSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetTeamsDistributeParallelForSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetTeamsDistributeParallelForSimdDirective> OMPTargetTeamsDistributeParallelForSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetTeamsDistributeParallelForSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetTeamsDistributeSimdDirective.cpp b/lib/AST/OMPTargetTeamsDistributeSimdDirective.cpp
index bd4bb6254..3e78b027a 100644
--- a/lib/AST/OMPTargetTeamsDistributeSimdDirective.cpp
+++ b/lib/AST/OMPTargetTeamsDistributeSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTargetTeamsDistributeSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetTeamsDistributeSimdDirective> OMPTargetTeamsDistributeSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetTeamsDistributeSimdDirective, ir::Operation>> OMPTargetTeamsDistributeSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetTeamsDistributeSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetTeamsDistributeSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetTeamsDistributeSimdDirective> OMPTargetTeamsDistributeSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetTeamsDistributeSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetTeamsGenericLoopDirective.cpp b/lib/AST/OMPTargetTeamsGenericLoopDirective.cpp
index 960b481c3..cd9da0475 100644
--- a/lib/AST/OMPTargetTeamsGenericLoopDirective.cpp
+++ b/lib/AST/OMPTargetTeamsGenericLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTargetTeamsGenericLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetTeamsGenericLoopDirective> OMPTargetTeamsGenericLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetTeamsGenericLoopDirective, ir::Operation>> OMPTargetTeamsGenericLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetTeamsGenericLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetTeamsGenericLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetTeamsGenericLoopDirective> OMPTargetTeamsGenericLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetTeamsGenericLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTargetUpdateDirective.cpp b/lib/AST/OMPTargetUpdateDirective.cpp
index f88e0e6d9..612127af6 100644
--- a/lib/AST/OMPTargetUpdateDirective.cpp
+++ b/lib/AST/OMPTargetUpdateDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTargetUpdateDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTargetUpdateDirective> OMPTargetUpdateDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTargetUpdateDirective, ir::Operation>> OMPTargetUpdateDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTargetUpdateDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTargetUpdateDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTargetUpdateDirective> OMPTargetUpdateDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTargetUpdateDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTaskDirective.cpp b/lib/AST/OMPTaskDirective.cpp
index 95d17b5c5..0024505f7 100644
--- a/lib/AST/OMPTaskDirective.cpp
+++ b/lib/AST/OMPTaskDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTaskDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTaskDirective> OMPTaskDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTaskDirective, ir::Operation>> OMPTaskDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTaskDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTaskDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTaskDirective> OMPTaskDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTaskDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTaskLoopDirective.cpp b/lib/AST/OMPTaskLoopDirective.cpp
index 2bf6d8fd4..edfe69e85 100644
--- a/lib/AST/OMPTaskLoopDirective.cpp
+++ b/lib/AST/OMPTaskLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTaskLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTaskLoopDirective> OMPTaskLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTaskLoopDirective, ir::Operation>> OMPTaskLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTaskLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTaskLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTaskLoopDirective> OMPTaskLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTaskLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTaskLoopSimdDirective.cpp b/lib/AST/OMPTaskLoopSimdDirective.cpp
index 9b6053f6a..fe5ee5c3c 100644
--- a/lib/AST/OMPTaskLoopSimdDirective.cpp
+++ b/lib/AST/OMPTaskLoopSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTaskLoopSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTaskLoopSimdDirective> OMPTaskLoopSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTaskLoopSimdDirective, ir::Operation>> OMPTaskLoopSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTaskLoopSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTaskLoopSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTaskLoopSimdDirective> OMPTaskLoopSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTaskLoopSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTaskgroupDirective.cpp b/lib/AST/OMPTaskgroupDirective.cpp
index dcd3bc9c2..5e9d64b58 100644
--- a/lib/AST/OMPTaskgroupDirective.cpp
+++ b/lib/AST/OMPTaskgroupDirective.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OMPTaskgroupDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTaskgroupDirective> OMPTaskgroupDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTaskgroupDirective, ir::Operation>> OMPTaskgroupDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTaskgroupDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTaskgroupDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTaskgroupDirective> OMPTaskgroupDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTaskgroupDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTaskwaitDirective.cpp b/lib/AST/OMPTaskwaitDirective.cpp
index dfbf4e673..874cf928e 100644
--- a/lib/AST/OMPTaskwaitDirective.cpp
+++ b/lib/AST/OMPTaskwaitDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTaskwaitDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTaskwaitDirective> OMPTaskwaitDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTaskwaitDirective, ir::Operation>> OMPTaskwaitDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTaskwaitDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTaskwaitDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTaskwaitDirective> OMPTaskwaitDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTaskwaitDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTaskyieldDirective.cpp b/lib/AST/OMPTaskyieldDirective.cpp
index a4721c332..bbe12ee8a 100644
--- a/lib/AST/OMPTaskyieldDirective.cpp
+++ b/lib/AST/OMPTaskyieldDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTaskyieldDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTaskyieldDirective> OMPTaskyieldDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTaskyieldDirective, ir::Operation>> OMPTaskyieldDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTaskyieldDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTaskyieldDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTaskyieldDirective> OMPTaskyieldDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTaskyieldDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTeamsDirective.cpp b/lib/AST/OMPTeamsDirective.cpp
index 68cf47097..45ee1e77d 100644
--- a/lib/AST/OMPTeamsDirective.cpp
+++ b/lib/AST/OMPTeamsDirective.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool OMPTeamsDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTeamsDirective> OMPTeamsDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTeamsDirective, ir::Operation>> OMPTeamsDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTeamsDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTeamsDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTeamsDirective> OMPTeamsDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTeamsDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTeamsDistributeDirective.cpp b/lib/AST/OMPTeamsDistributeDirective.cpp
index 7fff25c7c..3f4347849 100644
--- a/lib/AST/OMPTeamsDistributeDirective.cpp
+++ b/lib/AST/OMPTeamsDistributeDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTeamsDistributeDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTeamsDistributeDirective> OMPTeamsDistributeDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTeamsDistributeDirective, ir::Operation>> OMPTeamsDistributeDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTeamsDistributeDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTeamsDistributeDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTeamsDistributeDirective> OMPTeamsDistributeDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTeamsDistributeDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTeamsDistributeParallelForDirective.cpp b/lib/AST/OMPTeamsDistributeParallelForDirective.cpp
index 37443e2a6..aa7b33c26 100644
--- a/lib/AST/OMPTeamsDistributeParallelForDirective.cpp
+++ b/lib/AST/OMPTeamsDistributeParallelForDirective.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool OMPTeamsDistributeParallelForDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTeamsDistributeParallelForDirective> OMPTeamsDistributeParallelForDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTeamsDistributeParallelForDirective, ir::Operation>> OMPTeamsDistributeParallelForDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTeamsDistributeParallelForDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTeamsDistributeParallelForDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTeamsDistributeParallelForDirective> OMPTeamsDistributeParallelForDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTeamsDistributeParallelForDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTeamsDistributeParallelForSimdDirective.cpp b/lib/AST/OMPTeamsDistributeParallelForSimdDirective.cpp
index 747342721..cd20c8146 100644
--- a/lib/AST/OMPTeamsDistributeParallelForSimdDirective.cpp
+++ b/lib/AST/OMPTeamsDistributeParallelForSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTeamsDistributeParallelForSimdDirective::contains(const Token &tok) cons
   return false;
 }
 
-std::optional<OMPTeamsDistributeParallelForSimdDirective> OMPTeamsDistributeParallelForSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTeamsDistributeParallelForSimdDirective, ir::Operation>> OMPTeamsDistributeParallelForSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTeamsDistributeParallelForSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTeamsDistributeParallelForSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTeamsDistributeParallelForSimdDirective> OMPTeamsDistributeParallelForSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTeamsDistributeParallelForSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTeamsDistributeSimdDirective.cpp b/lib/AST/OMPTeamsDistributeSimdDirective.cpp
index 40e3a4abd..e214f7cf0 100644
--- a/lib/AST/OMPTeamsDistributeSimdDirective.cpp
+++ b/lib/AST/OMPTeamsDistributeSimdDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTeamsDistributeSimdDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTeamsDistributeSimdDirective> OMPTeamsDistributeSimdDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTeamsDistributeSimdDirective, ir::Operation>> OMPTeamsDistributeSimdDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTeamsDistributeSimdDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTeamsDistributeSimdDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTeamsDistributeSimdDirective> OMPTeamsDistributeSimdDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTeamsDistributeSimdDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTeamsGenericLoopDirective.cpp b/lib/AST/OMPTeamsGenericLoopDirective.cpp
index 04371f9a4..b82f25680 100644
--- a/lib/AST/OMPTeamsGenericLoopDirective.cpp
+++ b/lib/AST/OMPTeamsGenericLoopDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTeamsGenericLoopDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTeamsGenericLoopDirective> OMPTeamsGenericLoopDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTeamsGenericLoopDirective, ir::Operation>> OMPTeamsGenericLoopDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTeamsGenericLoopDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTeamsGenericLoopDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTeamsGenericLoopDirective> OMPTeamsGenericLoopDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTeamsGenericLoopDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPThreadPrivateDecl.cpp b/lib/AST/OMPThreadPrivateDecl.cpp
index e41fa68f1..d72f07a4a 100644
--- a/lib/AST/OMPThreadPrivateDecl.cpp
+++ b/lib/AST/OMPThreadPrivateDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool OMPThreadPrivateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPThreadPrivateDecl> OMPThreadPrivateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPThreadPrivateDecl, ir::Operation>> OMPThreadPrivateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kOMPThreadPrivateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPThreadPrivateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPThreadPrivateDecl> OMPThreadPrivateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kOMPThreadPrivateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPTileDirective.cpp b/lib/AST/OMPTileDirective.cpp
index 8d14105a2..8ac4ae5c5 100644
--- a/lib/AST/OMPTileDirective.cpp
+++ b/lib/AST/OMPTileDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPTileDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPTileDirective> OMPTileDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPTileDirective, ir::Operation>> OMPTileDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPTileDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPTileDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPTileDirective> OMPTileDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPTileDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OMPUnrollDirective.cpp b/lib/AST/OMPUnrollDirective.cpp
index e5f390e58..d78aaf253 100644
--- a/lib/AST/OMPUnrollDirective.cpp
+++ b/lib/AST/OMPUnrollDirective.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool OMPUnrollDirective::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OMPUnrollDirective> OMPUnrollDirective::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OMPUnrollDirective, ir::Operation>> OMPUnrollDirective::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOMPUnrollDirectiveDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OMPUnrollDirective, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OMPUnrollDirective> OMPUnrollDirective::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOMPUnrollDirectiveDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCArrayLiteral.cpp b/lib/AST/ObjCArrayLiteral.cpp
index 43c3b918a..85d67bf74 100644
--- a/lib/AST/ObjCArrayLiteral.cpp
+++ b/lib/AST/ObjCArrayLiteral.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ObjCArrayLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCArrayLiteral> ObjCArrayLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCArrayLiteral, ir::Operation>> ObjCArrayLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCArrayLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCArrayLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCArrayLiteral> ObjCArrayLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCArrayLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCAtCatchStmt.cpp b/lib/AST/ObjCAtCatchStmt.cpp
index ce4f814d5..1baa9646f 100644
--- a/lib/AST/ObjCAtCatchStmt.cpp
+++ b/lib/AST/ObjCAtCatchStmt.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool ObjCAtCatchStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCAtCatchStmt> ObjCAtCatchStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCAtCatchStmt, ir::Operation>> ObjCAtCatchStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCAtCatchStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCAtCatchStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCAtCatchStmt> ObjCAtCatchStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCAtCatchStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCAtDefsFieldDecl.cpp b/lib/AST/ObjCAtDefsFieldDecl.cpp
index 4ccea46d2..f3ba3f5c8 100644
--- a/lib/AST/ObjCAtDefsFieldDecl.cpp
+++ b/lib/AST/ObjCAtDefsFieldDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool ObjCAtDefsFieldDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCAtDefsFieldDecl> ObjCAtDefsFieldDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCAtDefsFieldDecl, ir::Operation>> ObjCAtDefsFieldDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCAtDefsFieldDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCAtDefsFieldDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCAtDefsFieldDecl> ObjCAtDefsFieldDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCAtDefsFieldDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCAtFinallyStmt.cpp b/lib/AST/ObjCAtFinallyStmt.cpp
index 5837096d5..f4fd50535 100644
--- a/lib/AST/ObjCAtFinallyStmt.cpp
+++ b/lib/AST/ObjCAtFinallyStmt.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -80,17 +78,10 @@ bool ObjCAtFinallyStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCAtFinallyStmt> ObjCAtFinallyStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCAtFinallyStmt, ir::Operation>> ObjCAtFinallyStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCAtFinallyStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCAtFinallyStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCAtFinallyStmt> ObjCAtFinallyStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCAtFinallyStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCAtSynchronizedStmt.cpp b/lib/AST/ObjCAtSynchronizedStmt.cpp
index 353b1929a..c1eb6c4d5 100644
--- a/lib/AST/ObjCAtSynchronizedStmt.cpp
+++ b/lib/AST/ObjCAtSynchronizedStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ObjCAtSynchronizedStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCAtSynchronizedStmt> ObjCAtSynchronizedStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCAtSynchronizedStmt, ir::Operation>> ObjCAtSynchronizedStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCAtSynchronizedStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCAtSynchronizedStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCAtSynchronizedStmt> ObjCAtSynchronizedStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCAtSynchronizedStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCAtThrowStmt.cpp b/lib/AST/ObjCAtThrowStmt.cpp
index cb6b85e5a..3e99100fd 100644
--- a/lib/AST/ObjCAtThrowStmt.cpp
+++ b/lib/AST/ObjCAtThrowStmt.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool ObjCAtThrowStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCAtThrowStmt> ObjCAtThrowStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCAtThrowStmt, ir::Operation>> ObjCAtThrowStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCAtThrowStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCAtThrowStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCAtThrowStmt> ObjCAtThrowStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCAtThrowStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCAtTryStmt.cpp b/lib/AST/ObjCAtTryStmt.cpp
index e16023e46..644fd41c4 100644
--- a/lib/AST/ObjCAtTryStmt.cpp
+++ b/lib/AST/ObjCAtTryStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ObjCAtTryStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCAtTryStmt> ObjCAtTryStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCAtTryStmt, ir::Operation>> ObjCAtTryStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCAtTryStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCAtTryStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCAtTryStmt> ObjCAtTryStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCAtTryStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCAutoreleasePoolStmt.cpp b/lib/AST/ObjCAutoreleasePoolStmt.cpp
index 0218f7212..ff855be05 100644
--- a/lib/AST/ObjCAutoreleasePoolStmt.cpp
+++ b/lib/AST/ObjCAutoreleasePoolStmt.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -80,17 +78,10 @@ bool ObjCAutoreleasePoolStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCAutoreleasePoolStmt> ObjCAutoreleasePoolStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCAutoreleasePoolStmt, ir::Operation>> ObjCAutoreleasePoolStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCAutoreleasePoolStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCAutoreleasePoolStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCAutoreleasePoolStmt> ObjCAutoreleasePoolStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCAutoreleasePoolStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCAvailabilityCheckExpr.cpp b/lib/AST/ObjCAvailabilityCheckExpr.cpp
index b8024acb0..017fbd105 100644
--- a/lib/AST/ObjCAvailabilityCheckExpr.cpp
+++ b/lib/AST/ObjCAvailabilityCheckExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ObjCAvailabilityCheckExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCAvailabilityCheckExpr> ObjCAvailabilityCheckExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCAvailabilityCheckExpr, ir::Operation>> ObjCAvailabilityCheckExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCAvailabilityCheckExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCAvailabilityCheckExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCAvailabilityCheckExpr> ObjCAvailabilityCheckExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCAvailabilityCheckExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCBoolLiteralExpr.cpp b/lib/AST/ObjCBoolLiteralExpr.cpp
index 46aa0b8bc..8fb7a780c 100644
--- a/lib/AST/ObjCBoolLiteralExpr.cpp
+++ b/lib/AST/ObjCBoolLiteralExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ObjCBoolLiteralExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCBoolLiteralExpr> ObjCBoolLiteralExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCBoolLiteralExpr, ir::Operation>> ObjCBoolLiteralExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCBoolLiteralExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCBoolLiteralExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCBoolLiteralExpr> ObjCBoolLiteralExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCBoolLiteralExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCBoxedExpr.cpp b/lib/AST/ObjCBoxedExpr.cpp
index fe1141fbe..e9972d403 100644
--- a/lib/AST/ObjCBoxedExpr.cpp
+++ b/lib/AST/ObjCBoxedExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ObjCBoxedExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCBoxedExpr> ObjCBoxedExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCBoxedExpr, ir::Operation>> ObjCBoxedExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCBoxedExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCBoxedExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCBoxedExpr> ObjCBoxedExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCBoxedExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCBridgedCastExpr.cpp b/lib/AST/ObjCBridgedCastExpr.cpp
index fdbadd330..0c6d58e89 100644
--- a/lib/AST/ObjCBridgedCastExpr.cpp
+++ b/lib/AST/ObjCBridgedCastExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool ObjCBridgedCastExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCBridgedCastExpr> ObjCBridgedCastExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCBridgedCastExpr, ir::Operation>> ObjCBridgedCastExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCBridgedCastExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCBridgedCastExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCBridgedCastExpr> ObjCBridgedCastExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCBridgedCastExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCCategoryDecl.cpp b/lib/AST/ObjCCategoryDecl.cpp
index cb8a9b26f..1c062a0a4 100644
--- a/lib/AST/ObjCCategoryDecl.cpp
+++ b/lib/AST/ObjCCategoryDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -88,17 +86,10 @@ bool ObjCCategoryDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCCategoryDecl> ObjCCategoryDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCCategoryDecl, ir::Operation>> ObjCCategoryDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCCategoryDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCCategoryDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCCategoryDecl> ObjCCategoryDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCCategoryDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCCategoryImplDecl.cpp b/lib/AST/ObjCCategoryImplDecl.cpp
index e57ea8e6d..58153fe26 100644
--- a/lib/AST/ObjCCategoryImplDecl.cpp
+++ b/lib/AST/ObjCCategoryImplDecl.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -85,17 +83,10 @@ bool ObjCCategoryImplDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCCategoryImplDecl> ObjCCategoryImplDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCCategoryImplDecl, ir::Operation>> ObjCCategoryImplDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCCategoryImplDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCCategoryImplDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCCategoryImplDecl> ObjCCategoryImplDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCCategoryImplDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCCompatibleAliasDecl.cpp b/lib/AST/ObjCCompatibleAliasDecl.cpp
index bebda3e32..4561e3db4 100644
--- a/lib/AST/ObjCCompatibleAliasDecl.cpp
+++ b/lib/AST/ObjCCompatibleAliasDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool ObjCCompatibleAliasDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCCompatibleAliasDecl> ObjCCompatibleAliasDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCCompatibleAliasDecl, ir::Operation>> ObjCCompatibleAliasDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCCompatibleAliasDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCCompatibleAliasDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCCompatibleAliasDecl> ObjCCompatibleAliasDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCCompatibleAliasDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCContainerDecl.cpp b/lib/AST/ObjCContainerDecl.cpp
index 452b29190..fb7529b80 100644
--- a/lib/AST/ObjCContainerDecl.cpp
+++ b/lib/AST/ObjCContainerDecl.cpp
@@ -20,8 +20,6 @@
 #include <multiplier/AST/ObjCInterfaceDecl.h>
 #include <multiplier/AST/ObjCProtocolDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -94,17 +92,10 @@ bool ObjCContainerDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCContainerDecl> ObjCContainerDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCContainerDecl, ir::Operation>> ObjCContainerDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCContainerDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCContainerDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCContainerDecl> ObjCContainerDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCContainerDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCDictionaryLiteral.cpp b/lib/AST/ObjCDictionaryLiteral.cpp
index 40e910696..42a4c93af 100644
--- a/lib/AST/ObjCDictionaryLiteral.cpp
+++ b/lib/AST/ObjCDictionaryLiteral.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ObjCDictionaryLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCDictionaryLiteral> ObjCDictionaryLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCDictionaryLiteral, ir::Operation>> ObjCDictionaryLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCDictionaryLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCDictionaryLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCDictionaryLiteral> ObjCDictionaryLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCDictionaryLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCEncodeExpr.cpp b/lib/AST/ObjCEncodeExpr.cpp
index 538515609..d59acd045 100644
--- a/lib/AST/ObjCEncodeExpr.cpp
+++ b/lib/AST/ObjCEncodeExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ObjCEncodeExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCEncodeExpr> ObjCEncodeExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCEncodeExpr, ir::Operation>> ObjCEncodeExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCEncodeExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCEncodeExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCEncodeExpr> ObjCEncodeExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCEncodeExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCForCollectionStmt.cpp b/lib/AST/ObjCForCollectionStmt.cpp
index abaf4e198..41544c308 100644
--- a/lib/AST/ObjCForCollectionStmt.cpp
+++ b/lib/AST/ObjCForCollectionStmt.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool ObjCForCollectionStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCForCollectionStmt> ObjCForCollectionStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCForCollectionStmt, ir::Operation>> ObjCForCollectionStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCForCollectionStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCForCollectionStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCForCollectionStmt> ObjCForCollectionStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCForCollectionStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCImplDecl.cpp b/lib/AST/ObjCImplDecl.cpp
index 9b7157d65..25feecb78 100644
--- a/lib/AST/ObjCImplDecl.cpp
+++ b/lib/AST/ObjCImplDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/AST/ObjCCategoryImplDecl.h>
 #include <multiplier/AST/ObjCImplementationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -88,17 +86,10 @@ bool ObjCImplDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCImplDecl> ObjCImplDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCImplDecl, ir::Operation>> ObjCImplDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCImplDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCImplDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCImplDecl> ObjCImplDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCImplDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCImplementationDecl.cpp b/lib/AST/ObjCImplementationDecl.cpp
index 4d03832b5..df96c4043 100644
--- a/lib/AST/ObjCImplementationDecl.cpp
+++ b/lib/AST/ObjCImplementationDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -87,17 +85,10 @@ bool ObjCImplementationDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCImplementationDecl> ObjCImplementationDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCImplementationDecl, ir::Operation>> ObjCImplementationDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCImplementationDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCImplementationDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCImplementationDecl> ObjCImplementationDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCImplementationDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCIndirectCopyRestoreExpr.cpp b/lib/AST/ObjCIndirectCopyRestoreExpr.cpp
index 0cce17b2b..1a0da0118 100644
--- a/lib/AST/ObjCIndirectCopyRestoreExpr.cpp
+++ b/lib/AST/ObjCIndirectCopyRestoreExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ObjCIndirectCopyRestoreExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCIndirectCopyRestoreExpr> ObjCIndirectCopyRestoreExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCIndirectCopyRestoreExpr, ir::Operation>> ObjCIndirectCopyRestoreExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCIndirectCopyRestoreExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCIndirectCopyRestoreExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCIndirectCopyRestoreExpr> ObjCIndirectCopyRestoreExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCIndirectCopyRestoreExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCInterfaceDecl.cpp b/lib/AST/ObjCInterfaceDecl.cpp
index 11e7f4757..abb3a2c60 100644
--- a/lib/AST/ObjCInterfaceDecl.cpp
+++ b/lib/AST/ObjCInterfaceDecl.cpp
@@ -19,8 +19,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/Type.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -89,17 +87,10 @@ bool ObjCInterfaceDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCInterfaceDecl> ObjCInterfaceDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCInterfaceDecl, ir::Operation>> ObjCInterfaceDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCInterfaceDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCInterfaceDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCInterfaceDecl> ObjCInterfaceDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCInterfaceDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCIsaExpr.cpp b/lib/AST/ObjCIsaExpr.cpp
index da06a166e..93db99592 100644
--- a/lib/AST/ObjCIsaExpr.cpp
+++ b/lib/AST/ObjCIsaExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ObjCIsaExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCIsaExpr> ObjCIsaExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCIsaExpr, ir::Operation>> ObjCIsaExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCIsaExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCIsaExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCIsaExpr> ObjCIsaExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCIsaExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCIvarDecl.cpp b/lib/AST/ObjCIvarDecl.cpp
index de1d93078..883a99a83 100644
--- a/lib/AST/ObjCIvarDecl.cpp
+++ b/lib/AST/ObjCIvarDecl.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -85,17 +83,10 @@ bool ObjCIvarDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCIvarDecl> ObjCIvarDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCIvarDecl, ir::Operation>> ObjCIvarDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCIvarDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCIvarDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCIvarDecl> ObjCIvarDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCIvarDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCIvarRefExpr.cpp b/lib/AST/ObjCIvarRefExpr.cpp
index 5caea781c..14d2e6272 100644
--- a/lib/AST/ObjCIvarRefExpr.cpp
+++ b/lib/AST/ObjCIvarRefExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ObjCIvarRefExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCIvarRefExpr> ObjCIvarRefExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCIvarRefExpr, ir::Operation>> ObjCIvarRefExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCIvarRefExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCIvarRefExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCIvarRefExpr> ObjCIvarRefExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCIvarRefExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCMessageExpr.cpp b/lib/AST/ObjCMessageExpr.cpp
index 46d2752b2..3b4706412 100644
--- a/lib/AST/ObjCMessageExpr.cpp
+++ b/lib/AST/ObjCMessageExpr.cpp
@@ -16,8 +16,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Stmt.h"
@@ -86,17 +84,10 @@ bool ObjCMessageExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCMessageExpr> ObjCMessageExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCMessageExpr, ir::Operation>> ObjCMessageExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCMessageExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCMessageExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCMessageExpr> ObjCMessageExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCMessageExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCMethodDecl.cpp b/lib/AST/ObjCMethodDecl.cpp
index d8d9d0050..fa0984cb1 100644
--- a/lib/AST/ObjCMethodDecl.cpp
+++ b/lib/AST/ObjCMethodDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/Type.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -88,17 +86,10 @@ bool ObjCMethodDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCMethodDecl> ObjCMethodDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCMethodDecl, ir::Operation>> ObjCMethodDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCMethodDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCMethodDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCMethodDecl> ObjCMethodDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCMethodDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCPropertyDecl.cpp b/lib/AST/ObjCPropertyDecl.cpp
index 3358927c0..1dcf30e51 100644
--- a/lib/AST/ObjCPropertyDecl.cpp
+++ b/lib/AST/ObjCPropertyDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/Type.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool ObjCPropertyDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCPropertyDecl> ObjCPropertyDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCPropertyDecl, ir::Operation>> ObjCPropertyDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCPropertyDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCPropertyDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCPropertyDecl> ObjCPropertyDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCPropertyDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCPropertyImplDecl.cpp b/lib/AST/ObjCPropertyImplDecl.cpp
index ce4eedfcf..38d97d749 100644
--- a/lib/AST/ObjCPropertyImplDecl.cpp
+++ b/lib/AST/ObjCPropertyImplDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool ObjCPropertyImplDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCPropertyImplDecl> ObjCPropertyImplDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCPropertyImplDecl, ir::Operation>> ObjCPropertyImplDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCPropertyImplDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCPropertyImplDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCPropertyImplDecl> ObjCPropertyImplDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCPropertyImplDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCPropertyRefExpr.cpp b/lib/AST/ObjCPropertyRefExpr.cpp
index 7b9b814d6..556279d38 100644
--- a/lib/AST/ObjCPropertyRefExpr.cpp
+++ b/lib/AST/ObjCPropertyRefExpr.cpp
@@ -17,8 +17,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -86,17 +84,10 @@ bool ObjCPropertyRefExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCPropertyRefExpr> ObjCPropertyRefExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCPropertyRefExpr, ir::Operation>> ObjCPropertyRefExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCPropertyRefExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCPropertyRefExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCPropertyRefExpr> ObjCPropertyRefExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCPropertyRefExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCProtocolDecl.cpp b/lib/AST/ObjCProtocolDecl.cpp
index 1105236f2..e717635de 100644
--- a/lib/AST/ObjCProtocolDecl.cpp
+++ b/lib/AST/ObjCProtocolDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -84,17 +82,10 @@ bool ObjCProtocolDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCProtocolDecl> ObjCProtocolDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCProtocolDecl, ir::Operation>> ObjCProtocolDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCProtocolDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCProtocolDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCProtocolDecl> ObjCProtocolDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCProtocolDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCProtocolExpr.cpp b/lib/AST/ObjCProtocolExpr.cpp
index 18f5a3b7f..fdd10ea3a 100644
--- a/lib/AST/ObjCProtocolExpr.cpp
+++ b/lib/AST/ObjCProtocolExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ObjCProtocolExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCProtocolExpr> ObjCProtocolExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCProtocolExpr, ir::Operation>> ObjCProtocolExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCProtocolExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCProtocolExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCProtocolExpr> ObjCProtocolExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCProtocolExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCSelectorExpr.cpp b/lib/AST/ObjCSelectorExpr.cpp
index df21e159f..f04a383cd 100644
--- a/lib/AST/ObjCSelectorExpr.cpp
+++ b/lib/AST/ObjCSelectorExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ObjCSelectorExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCSelectorExpr> ObjCSelectorExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCSelectorExpr, ir::Operation>> ObjCSelectorExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCSelectorExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCSelectorExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCSelectorExpr> ObjCSelectorExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCSelectorExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCStringLiteral.cpp b/lib/AST/ObjCStringLiteral.cpp
index a5fd853bf..9c82bf571 100644
--- a/lib/AST/ObjCStringLiteral.cpp
+++ b/lib/AST/ObjCStringLiteral.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ObjCStringLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCStringLiteral> ObjCStringLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCStringLiteral, ir::Operation>> ObjCStringLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCStringLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCStringLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCStringLiteral> ObjCStringLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCStringLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCSubscriptRefExpr.cpp b/lib/AST/ObjCSubscriptRefExpr.cpp
index b7ee1ee5e..d1d99e144 100644
--- a/lib/AST/ObjCSubscriptRefExpr.cpp
+++ b/lib/AST/ObjCSubscriptRefExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool ObjCSubscriptRefExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCSubscriptRefExpr> ObjCSubscriptRefExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCSubscriptRefExpr, ir::Operation>> ObjCSubscriptRefExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kObjCSubscriptRefExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCSubscriptRefExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCSubscriptRefExpr> ObjCSubscriptRefExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kObjCSubscriptRefExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ObjCTypeParamDecl.cpp b/lib/AST/ObjCTypeParamDecl.cpp
index f24309313..20f3b3b99 100644
--- a/lib/AST/ObjCTypeParamDecl.cpp
+++ b/lib/AST/ObjCTypeParamDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/TypeDecl.h>
 #include <multiplier/AST/TypedefNameDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool ObjCTypeParamDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ObjCTypeParamDecl> ObjCTypeParamDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ObjCTypeParamDecl, ir::Operation>> ObjCTypeParamDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kObjCTypeParamDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ObjCTypeParamDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ObjCTypeParamDecl> ObjCTypeParamDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kObjCTypeParamDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OffsetOfExpr.cpp b/lib/AST/OffsetOfExpr.cpp
index bce5818d2..748d91b84 100644
--- a/lib/AST/OffsetOfExpr.cpp
+++ b/lib/AST/OffsetOfExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OffsetOfExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OffsetOfExpr> OffsetOfExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OffsetOfExpr, ir::Operation>> OffsetOfExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOffsetOfExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OffsetOfExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OffsetOfExpr> OffsetOfExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOffsetOfExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OpaqueValueExpr.cpp b/lib/AST/OpaqueValueExpr.cpp
index ed690c8e5..4c51ba6c3 100644
--- a/lib/AST/OpaqueValueExpr.cpp
+++ b/lib/AST/OpaqueValueExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool OpaqueValueExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OpaqueValueExpr> OpaqueValueExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OpaqueValueExpr, ir::Operation>> OpaqueValueExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOpaqueValueExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OpaqueValueExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OpaqueValueExpr> OpaqueValueExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOpaqueValueExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/OverloadExpr.cpp b/lib/AST/OverloadExpr.cpp
index abf5b3e4e..9fe8e9517 100644
--- a/lib/AST/OverloadExpr.cpp
+++ b/lib/AST/OverloadExpr.cpp
@@ -17,8 +17,6 @@
 #include <multiplier/AST/UnresolvedLookupExpr.h>
 #include <multiplier/AST/UnresolvedMemberExpr.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -87,17 +85,10 @@ bool OverloadExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<OverloadExpr> OverloadExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<OverloadExpr, ir::Operation>> OverloadExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kOverloadExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<OverloadExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<OverloadExpr> OverloadExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kOverloadExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/PackExpansionExpr.cpp b/lib/AST/PackExpansionExpr.cpp
index 40ca26cf1..5004e13b9 100644
--- a/lib/AST/PackExpansionExpr.cpp
+++ b/lib/AST/PackExpansionExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool PackExpansionExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<PackExpansionExpr> PackExpansionExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<PackExpansionExpr, ir::Operation>> PackExpansionExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kPackExpansionExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<PackExpansionExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<PackExpansionExpr> PackExpansionExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kPackExpansionExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ParenExpr.cpp b/lib/AST/ParenExpr.cpp
index 955282d46..ad6211bed 100644
--- a/lib/AST/ParenExpr.cpp
+++ b/lib/AST/ParenExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ParenExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ParenExpr> ParenExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ParenExpr, ir::Operation>> ParenExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kParenExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ParenExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ParenExpr> ParenExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kParenExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ParenListExpr.cpp b/lib/AST/ParenListExpr.cpp
index 1c0e60449..13a53df41 100644
--- a/lib/AST/ParenListExpr.cpp
+++ b/lib/AST/ParenListExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ParenListExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ParenListExpr> ParenListExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ParenListExpr, ir::Operation>> ParenListExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kParenListExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ParenListExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ParenListExpr> ParenListExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kParenListExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ParmVarDecl.cpp b/lib/AST/ParmVarDecl.cpp
index 1100110af..6d4a7695f 100644
--- a/lib/AST/ParmVarDecl.cpp
+++ b/lib/AST/ParmVarDecl.cpp
@@ -17,8 +17,6 @@
 #include <multiplier/AST/ValueDecl.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -87,17 +85,10 @@ bool ParmVarDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ParmVarDecl> ParmVarDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ParmVarDecl, ir::Operation>> ParmVarDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kParmVarDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ParmVarDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ParmVarDecl> ParmVarDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kParmVarDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/PragmaCommentDecl.cpp b/lib/AST/PragmaCommentDecl.cpp
index 87e18f79b..628b825ce 100644
--- a/lib/AST/PragmaCommentDecl.cpp
+++ b/lib/AST/PragmaCommentDecl.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -80,17 +78,10 @@ bool PragmaCommentDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<PragmaCommentDecl> PragmaCommentDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<PragmaCommentDecl, ir::Operation>> PragmaCommentDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kPragmaCommentDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<PragmaCommentDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<PragmaCommentDecl> PragmaCommentDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kPragmaCommentDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/PragmaDetectMismatchDecl.cpp b/lib/AST/PragmaDetectMismatchDecl.cpp
index c4398af21..2202cddff 100644
--- a/lib/AST/PragmaDetectMismatchDecl.cpp
+++ b/lib/AST/PragmaDetectMismatchDecl.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -80,17 +78,10 @@ bool PragmaDetectMismatchDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<PragmaDetectMismatchDecl> PragmaDetectMismatchDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<PragmaDetectMismatchDecl, ir::Operation>> PragmaDetectMismatchDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kPragmaDetectMismatchDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<PragmaDetectMismatchDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<PragmaDetectMismatchDecl> PragmaDetectMismatchDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kPragmaDetectMismatchDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/PredefinedExpr.cpp b/lib/AST/PredefinedExpr.cpp
index 3be8f8be9..11d826218 100644
--- a/lib/AST/PredefinedExpr.cpp
+++ b/lib/AST/PredefinedExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool PredefinedExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<PredefinedExpr> PredefinedExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<PredefinedExpr, ir::Operation>> PredefinedExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kPredefinedExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<PredefinedExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<PredefinedExpr> PredefinedExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kPredefinedExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/PseudoObjectExpr.cpp b/lib/AST/PseudoObjectExpr.cpp
index 355036d5b..fc0894753 100644
--- a/lib/AST/PseudoObjectExpr.cpp
+++ b/lib/AST/PseudoObjectExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool PseudoObjectExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<PseudoObjectExpr> PseudoObjectExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<PseudoObjectExpr, ir::Operation>> PseudoObjectExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kPseudoObjectExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<PseudoObjectExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<PseudoObjectExpr> PseudoObjectExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kPseudoObjectExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/RecordDecl.cpp b/lib/AST/RecordDecl.cpp
index 355e9d69c..050893e43 100644
--- a/lib/AST/RecordDecl.cpp
+++ b/lib/AST/RecordDecl.cpp
@@ -19,8 +19,6 @@
 #include <multiplier/AST/ClassTemplatePartialSpecializationDecl.h>
 #include <multiplier/AST/ClassTemplateSpecializationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -91,17 +89,10 @@ bool RecordDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<RecordDecl> RecordDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<RecordDecl, ir::Operation>> RecordDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kRecordDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<RecordDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<RecordDecl> RecordDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kRecordDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/RecoveryExpr.cpp b/lib/AST/RecoveryExpr.cpp
index 6bb54cff8..cc8aa4c5f 100644
--- a/lib/AST/RecoveryExpr.cpp
+++ b/lib/AST/RecoveryExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool RecoveryExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<RecoveryExpr> RecoveryExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<RecoveryExpr, ir::Operation>> RecoveryExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kRecoveryExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<RecoveryExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<RecoveryExpr> RecoveryExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kRecoveryExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/RedeclarableTemplateDecl.cpp b/lib/AST/RedeclarableTemplateDecl.cpp
index 2b3f2496d..0976f8d2b 100644
--- a/lib/AST/RedeclarableTemplateDecl.cpp
+++ b/lib/AST/RedeclarableTemplateDecl.cpp
@@ -17,8 +17,6 @@
 #include <multiplier/AST/TypeAliasTemplateDecl.h>
 #include <multiplier/AST/VarTemplateDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -89,17 +87,10 @@ bool RedeclarableTemplateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<RedeclarableTemplateDecl> RedeclarableTemplateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<RedeclarableTemplateDecl, ir::Operation>> RedeclarableTemplateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kRedeclarableTemplateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<RedeclarableTemplateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<RedeclarableTemplateDecl> RedeclarableTemplateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kRedeclarableTemplateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/RequiresExpr.cpp b/lib/AST/RequiresExpr.cpp
index bec22d72d..a4341256c 100644
--- a/lib/AST/RequiresExpr.cpp
+++ b/lib/AST/RequiresExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool RequiresExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<RequiresExpr> RequiresExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<RequiresExpr, ir::Operation>> RequiresExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kRequiresExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<RequiresExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<RequiresExpr> RequiresExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kRequiresExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/RequiresExprBodyDecl.cpp b/lib/AST/RequiresExprBodyDecl.cpp
index c5b8dc42f..270dcd62a 100644
--- a/lib/AST/RequiresExprBodyDecl.cpp
+++ b/lib/AST/RequiresExprBodyDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool RequiresExprBodyDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<RequiresExprBodyDecl> RequiresExprBodyDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<RequiresExprBodyDecl, ir::Operation>> RequiresExprBodyDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kRequiresExprBodyDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<RequiresExprBodyDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<RequiresExprBodyDecl> RequiresExprBodyDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kRequiresExprBodyDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ReturnStmt.cpp b/lib/AST/ReturnStmt.cpp
index 618730232..79862c35c 100644
--- a/lib/AST/ReturnStmt.cpp
+++ b/lib/AST/ReturnStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ReturnStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ReturnStmt> ReturnStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ReturnStmt, ir::Operation>> ReturnStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kReturnStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ReturnStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ReturnStmt> ReturnStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kReturnStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SEHExceptStmt.cpp b/lib/AST/SEHExceptStmt.cpp
index e7b6f6422..025135dbf 100644
--- a/lib/AST/SEHExceptStmt.cpp
+++ b/lib/AST/SEHExceptStmt.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool SEHExceptStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SEHExceptStmt> SEHExceptStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SEHExceptStmt, ir::Operation>> SEHExceptStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSEHExceptStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SEHExceptStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SEHExceptStmt> SEHExceptStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSEHExceptStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SEHFinallyStmt.cpp b/lib/AST/SEHFinallyStmt.cpp
index e31918268..2ff702235 100644
--- a/lib/AST/SEHFinallyStmt.cpp
+++ b/lib/AST/SEHFinallyStmt.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -81,17 +79,10 @@ bool SEHFinallyStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SEHFinallyStmt> SEHFinallyStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SEHFinallyStmt, ir::Operation>> SEHFinallyStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSEHFinallyStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SEHFinallyStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SEHFinallyStmt> SEHFinallyStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSEHFinallyStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SEHLeaveStmt.cpp b/lib/AST/SEHLeaveStmt.cpp
index 688b8b3aa..b9d035b4a 100644
--- a/lib/AST/SEHLeaveStmt.cpp
+++ b/lib/AST/SEHLeaveStmt.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -80,17 +78,10 @@ bool SEHLeaveStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SEHLeaveStmt> SEHLeaveStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SEHLeaveStmt, ir::Operation>> SEHLeaveStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSEHLeaveStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SEHLeaveStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SEHLeaveStmt> SEHLeaveStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSEHLeaveStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SEHTryStmt.cpp b/lib/AST/SEHTryStmt.cpp
index 73613250b..3e4fd8555 100644
--- a/lib/AST/SEHTryStmt.cpp
+++ b/lib/AST/SEHTryStmt.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool SEHTryStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SEHTryStmt> SEHTryStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SEHTryStmt, ir::Operation>> SEHTryStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSEHTryStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SEHTryStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SEHTryStmt> SEHTryStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSEHTryStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SYCLUniqueStableNameExpr.cpp b/lib/AST/SYCLUniqueStableNameExpr.cpp
index 9f27c083e..e56cc974e 100644
--- a/lib/AST/SYCLUniqueStableNameExpr.cpp
+++ b/lib/AST/SYCLUniqueStableNameExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool SYCLUniqueStableNameExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SYCLUniqueStableNameExpr> SYCLUniqueStableNameExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SYCLUniqueStableNameExpr, ir::Operation>> SYCLUniqueStableNameExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSYCLUniqueStableNameExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SYCLUniqueStableNameExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SYCLUniqueStableNameExpr> SYCLUniqueStableNameExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSYCLUniqueStableNameExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ShuffleVectorExpr.cpp b/lib/AST/ShuffleVectorExpr.cpp
index b7133e68c..f0d5d8078 100644
--- a/lib/AST/ShuffleVectorExpr.cpp
+++ b/lib/AST/ShuffleVectorExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool ShuffleVectorExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ShuffleVectorExpr> ShuffleVectorExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ShuffleVectorExpr, ir::Operation>> ShuffleVectorExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kShuffleVectorExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ShuffleVectorExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ShuffleVectorExpr> ShuffleVectorExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kShuffleVectorExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SizeOfPackExpr.cpp b/lib/AST/SizeOfPackExpr.cpp
index 63ae4f6c2..d7d9bb9bf 100644
--- a/lib/AST/SizeOfPackExpr.cpp
+++ b/lib/AST/SizeOfPackExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool SizeOfPackExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SizeOfPackExpr> SizeOfPackExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SizeOfPackExpr, ir::Operation>> SizeOfPackExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSizeOfPackExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SizeOfPackExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SizeOfPackExpr> SizeOfPackExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSizeOfPackExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SourceLocExpr.cpp b/lib/AST/SourceLocExpr.cpp
index afe0fec9a..58352d66f 100644
--- a/lib/AST/SourceLocExpr.cpp
+++ b/lib/AST/SourceLocExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool SourceLocExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SourceLocExpr> SourceLocExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SourceLocExpr, ir::Operation>> SourceLocExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSourceLocExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SourceLocExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SourceLocExpr> SourceLocExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSourceLocExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/StaticAssertDecl.cpp b/lib/AST/StaticAssertDecl.cpp
index 9214ab599..2c04467f7 100644
--- a/lib/AST/StaticAssertDecl.cpp
+++ b/lib/AST/StaticAssertDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool StaticAssertDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<StaticAssertDecl> StaticAssertDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<StaticAssertDecl, ir::Operation>> StaticAssertDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kStaticAssertDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<StaticAssertDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<StaticAssertDecl> StaticAssertDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kStaticAssertDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/Stmt.cpp b/lib/AST/Stmt.cpp
index 62185ef8e..13414026c 100644
--- a/lib/AST/Stmt.cpp
+++ b/lib/AST/Stmt.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/Frontend/File.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../File.h"
 #include "../Fragment.h"
diff --git a/lib/AST/StmtExpr.cpp b/lib/AST/StmtExpr.cpp
index 3e8698cd6..738ea1e2f 100644
--- a/lib/AST/StmtExpr.cpp
+++ b/lib/AST/StmtExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool StmtExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<StmtExpr> StmtExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<StmtExpr, ir::Operation>> StmtExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kStmtExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<StmtExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<StmtExpr> StmtExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kStmtExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/StringLiteral.cpp b/lib/AST/StringLiteral.cpp
index 299d55c3e..6265032f7 100644
--- a/lib/AST/StringLiteral.cpp
+++ b/lib/AST/StringLiteral.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool StringLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<StringLiteral> StringLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<StringLiteral, ir::Operation>> StringLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kStringLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<StringLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<StringLiteral> StringLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kStringLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SubstNonTypeTemplateParmExpr.cpp b/lib/AST/SubstNonTypeTemplateParmExpr.cpp
index a05da26f2..c44668a43 100644
--- a/lib/AST/SubstNonTypeTemplateParmExpr.cpp
+++ b/lib/AST/SubstNonTypeTemplateParmExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool SubstNonTypeTemplateParmExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SubstNonTypeTemplateParmExpr> SubstNonTypeTemplateParmExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SubstNonTypeTemplateParmExpr, ir::Operation>> SubstNonTypeTemplateParmExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSubstNonTypeTemplateParmExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SubstNonTypeTemplateParmExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SubstNonTypeTemplateParmExpr> SubstNonTypeTemplateParmExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSubstNonTypeTemplateParmExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SubstNonTypeTemplateParmPackExpr.cpp b/lib/AST/SubstNonTypeTemplateParmPackExpr.cpp
index 8be48e554..2b7dbec7c 100644
--- a/lib/AST/SubstNonTypeTemplateParmPackExpr.cpp
+++ b/lib/AST/SubstNonTypeTemplateParmPackExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool SubstNonTypeTemplateParmPackExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SubstNonTypeTemplateParmPackExpr> SubstNonTypeTemplateParmPackExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SubstNonTypeTemplateParmPackExpr, ir::Operation>> SubstNonTypeTemplateParmPackExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSubstNonTypeTemplateParmPackExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SubstNonTypeTemplateParmPackExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SubstNonTypeTemplateParmPackExpr> SubstNonTypeTemplateParmPackExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSubstNonTypeTemplateParmPackExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SwitchCase.cpp b/lib/AST/SwitchCase.cpp
index 084753294..660527522 100644
--- a/lib/AST/SwitchCase.cpp
+++ b/lib/AST/SwitchCase.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/CaseStmt.h>
 #include <multiplier/AST/DefaultStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool SwitchCase::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SwitchCase> SwitchCase::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SwitchCase, ir::Operation>> SwitchCase::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSwitchCaseDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SwitchCase, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SwitchCase> SwitchCase::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSwitchCaseDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/SwitchStmt.cpp b/lib/AST/SwitchStmt.cpp
index be89b29b6..98485fe83 100644
--- a/lib/AST/SwitchStmt.cpp
+++ b/lib/AST/SwitchStmt.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool SwitchStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<SwitchStmt> SwitchStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<SwitchStmt, ir::Operation>> SwitchStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kSwitchStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<SwitchStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<SwitchStmt> SwitchStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kSwitchStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TagDecl.cpp b/lib/AST/TagDecl.cpp
index 20d429376..19f58a874 100644
--- a/lib/AST/TagDecl.cpp
+++ b/lib/AST/TagDecl.cpp
@@ -21,8 +21,6 @@
 #include <multiplier/AST/EnumDecl.h>
 #include <multiplier/AST/RecordDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Fragment.h"
 #include "../Decl.h"
@@ -95,17 +93,10 @@ bool TagDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TagDecl> TagDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TagDecl, ir::Operation>> TagDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTagDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TagDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TagDecl> TagDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTagDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TemplateDecl.cpp b/lib/AST/TemplateDecl.cpp
index 1728f07ff..a25378a5e 100644
--- a/lib/AST/TemplateDecl.cpp
+++ b/lib/AST/TemplateDecl.cpp
@@ -20,8 +20,6 @@
 #include <multiplier/AST/TypeAliasTemplateDecl.h>
 #include <multiplier/AST/VarTemplateDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -95,17 +93,10 @@ bool TemplateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TemplateDecl> TemplateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TemplateDecl, ir::Operation>> TemplateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTemplateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TemplateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TemplateDecl> TemplateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTemplateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TemplateParamObjectDecl.cpp b/lib/AST/TemplateParamObjectDecl.cpp
index d21b92ef6..54760253b 100644
--- a/lib/AST/TemplateParamObjectDecl.cpp
+++ b/lib/AST/TemplateParamObjectDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool TemplateParamObjectDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TemplateParamObjectDecl> TemplateParamObjectDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TemplateParamObjectDecl, ir::Operation>> TemplateParamObjectDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTemplateParamObjectDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TemplateParamObjectDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TemplateParamObjectDecl> TemplateParamObjectDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTemplateParamObjectDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TemplateTemplateParmDecl.cpp b/lib/AST/TemplateTemplateParmDecl.cpp
index ffc7fbc5d..16d0a145c 100644
--- a/lib/AST/TemplateTemplateParmDecl.cpp
+++ b/lib/AST/TemplateTemplateParmDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/TemplateDecl.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool TemplateTemplateParmDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TemplateTemplateParmDecl> TemplateTemplateParmDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TemplateTemplateParmDecl, ir::Operation>> TemplateTemplateParmDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTemplateTemplateParmDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TemplateTemplateParmDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TemplateTemplateParmDecl> TemplateTemplateParmDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTemplateTemplateParmDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TemplateTypeParmDecl.cpp b/lib/AST/TemplateTypeParmDecl.cpp
index f94c41ade..573e48b90 100644
--- a/lib/AST/TemplateTypeParmDecl.cpp
+++ b/lib/AST/TemplateTypeParmDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/TypeDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool TemplateTypeParmDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TemplateTypeParmDecl> TemplateTypeParmDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TemplateTypeParmDecl, ir::Operation>> TemplateTypeParmDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTemplateTypeParmDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TemplateTypeParmDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TemplateTypeParmDecl> TemplateTypeParmDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTemplateTypeParmDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TopLevelStmtDecl.cpp b/lib/AST/TopLevelStmtDecl.cpp
index e7e5deee8..67131fc04 100644
--- a/lib/AST/TopLevelStmtDecl.cpp
+++ b/lib/AST/TopLevelStmtDecl.cpp
@@ -11,8 +11,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -80,17 +78,10 @@ bool TopLevelStmtDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TopLevelStmtDecl> TopLevelStmtDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TopLevelStmtDecl, ir::Operation>> TopLevelStmtDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTopLevelStmtDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TopLevelStmtDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TopLevelStmtDecl> TopLevelStmtDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTopLevelStmtDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TranslationUnitDecl.cpp b/lib/AST/TranslationUnitDecl.cpp
index ea3b7e5cb..9ef00627b 100644
--- a/lib/AST/TranslationUnitDecl.cpp
+++ b/lib/AST/TranslationUnitDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool TranslationUnitDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TranslationUnitDecl> TranslationUnitDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TranslationUnitDecl, ir::Operation>> TranslationUnitDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTranslationUnitDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TranslationUnitDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TranslationUnitDecl> TranslationUnitDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTranslationUnitDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TypeAliasDecl.cpp b/lib/AST/TypeAliasDecl.cpp
index 64e153e05..05075df1c 100644
--- a/lib/AST/TypeAliasDecl.cpp
+++ b/lib/AST/TypeAliasDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/TypeDecl.h>
 #include <multiplier/AST/TypedefNameDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool TypeAliasDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TypeAliasDecl> TypeAliasDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TypeAliasDecl, ir::Operation>> TypeAliasDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTypeAliasDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TypeAliasDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TypeAliasDecl> TypeAliasDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTypeAliasDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TypeAliasTemplateDecl.cpp b/lib/AST/TypeAliasTemplateDecl.cpp
index 7efc0766c..3f65ba49c 100644
--- a/lib/AST/TypeAliasTemplateDecl.cpp
+++ b/lib/AST/TypeAliasTemplateDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/TemplateDecl.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool TypeAliasTemplateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TypeAliasTemplateDecl> TypeAliasTemplateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TypeAliasTemplateDecl, ir::Operation>> TypeAliasTemplateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTypeAliasTemplateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TypeAliasTemplateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TypeAliasTemplateDecl> TypeAliasTemplateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTypeAliasTemplateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TypeDecl.cpp b/lib/AST/TypeDecl.cpp
index b13cb3556..3e86570af 100644
--- a/lib/AST/TypeDecl.cpp
+++ b/lib/AST/TypeDecl.cpp
@@ -23,8 +23,6 @@
 #include <multiplier/AST/TypedefDecl.h>
 #include <multiplier/AST/UnresolvedUsingTypenameDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -101,17 +99,10 @@ bool TypeDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TypeDecl> TypeDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TypeDecl, ir::Operation>> TypeDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTypeDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TypeDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TypeDecl> TypeDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTypeDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TypeTraitExpr.cpp b/lib/AST/TypeTraitExpr.cpp
index 25e30593d..2ced70c1f 100644
--- a/lib/AST/TypeTraitExpr.cpp
+++ b/lib/AST/TypeTraitExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool TypeTraitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TypeTraitExpr> TypeTraitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TypeTraitExpr, ir::Operation>> TypeTraitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kTypeTraitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TypeTraitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TypeTraitExpr> TypeTraitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kTypeTraitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TypedefDecl.cpp b/lib/AST/TypedefDecl.cpp
index 125e3e1a0..6b8822edc 100644
--- a/lib/AST/TypedefDecl.cpp
+++ b/lib/AST/TypedefDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/TypeDecl.h>
 #include <multiplier/AST/TypedefNameDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool TypedefDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TypedefDecl> TypedefDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TypedefDecl, ir::Operation>> TypedefDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTypedefDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TypedefDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TypedefDecl> TypedefDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTypedefDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TypedefNameDecl.cpp b/lib/AST/TypedefNameDecl.cpp
index d317c8b4c..af1284cdb 100644
--- a/lib/AST/TypedefNameDecl.cpp
+++ b/lib/AST/TypedefNameDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/AST/TypeAliasDecl.h>
 #include <multiplier/AST/TypedefDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -89,17 +87,10 @@ bool TypedefNameDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TypedefNameDecl> TypedefNameDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TypedefNameDecl, ir::Operation>> TypedefNameDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kTypedefNameDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TypedefNameDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TypedefNameDecl> TypedefNameDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kTypedefNameDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/TypoExpr.cpp b/lib/AST/TypoExpr.cpp
index dcbeb4897..649dbdb6a 100644
--- a/lib/AST/TypoExpr.cpp
+++ b/lib/AST/TypoExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool TypoExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<TypoExpr> TypoExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<TypoExpr, ir::Operation>> TypoExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kTypoExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<TypoExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<TypoExpr> TypoExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kTypoExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UnaryExprOrTypeTraitExpr.cpp b/lib/AST/UnaryExprOrTypeTraitExpr.cpp
index c8afb3508..09aed0a86 100644
--- a/lib/AST/UnaryExprOrTypeTraitExpr.cpp
+++ b/lib/AST/UnaryExprOrTypeTraitExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool UnaryExprOrTypeTraitExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UnaryExprOrTypeTraitExpr> UnaryExprOrTypeTraitExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UnaryExprOrTypeTraitExpr, ir::Operation>> UnaryExprOrTypeTraitExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kUnaryExprOrTypeTraitExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UnaryExprOrTypeTraitExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UnaryExprOrTypeTraitExpr> UnaryExprOrTypeTraitExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kUnaryExprOrTypeTraitExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UnaryOperator.cpp b/lib/AST/UnaryOperator.cpp
index b946a27d8..3ae920ad0 100644
--- a/lib/AST/UnaryOperator.cpp
+++ b/lib/AST/UnaryOperator.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool UnaryOperator::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UnaryOperator> UnaryOperator::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UnaryOperator, ir::Operation>> UnaryOperator::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kUnaryOperatorDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UnaryOperator, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UnaryOperator> UnaryOperator::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kUnaryOperatorDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UnnamedGlobalConstantDecl.cpp b/lib/AST/UnnamedGlobalConstantDecl.cpp
index a88a4710d..f338c572a 100644
--- a/lib/AST/UnnamedGlobalConstantDecl.cpp
+++ b/lib/AST/UnnamedGlobalConstantDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool UnnamedGlobalConstantDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UnnamedGlobalConstantDecl> UnnamedGlobalConstantDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UnnamedGlobalConstantDecl, ir::Operation>> UnnamedGlobalConstantDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kUnnamedGlobalConstantDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UnnamedGlobalConstantDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UnnamedGlobalConstantDecl> UnnamedGlobalConstantDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kUnnamedGlobalConstantDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UnresolvedLookupExpr.cpp b/lib/AST/UnresolvedLookupExpr.cpp
index 0b8b5c5c0..2f0883c8f 100644
--- a/lib/AST/UnresolvedLookupExpr.cpp
+++ b/lib/AST/UnresolvedLookupExpr.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool UnresolvedLookupExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UnresolvedLookupExpr> UnresolvedLookupExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UnresolvedLookupExpr, ir::Operation>> UnresolvedLookupExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kUnresolvedLookupExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UnresolvedLookupExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UnresolvedLookupExpr> UnresolvedLookupExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kUnresolvedLookupExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UnresolvedMemberExpr.cpp b/lib/AST/UnresolvedMemberExpr.cpp
index 1f8a89152..d90b9f4c9 100644
--- a/lib/AST/UnresolvedMemberExpr.cpp
+++ b/lib/AST/UnresolvedMemberExpr.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -84,17 +82,10 @@ bool UnresolvedMemberExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UnresolvedMemberExpr> UnresolvedMemberExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UnresolvedMemberExpr, ir::Operation>> UnresolvedMemberExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kUnresolvedMemberExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UnresolvedMemberExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UnresolvedMemberExpr> UnresolvedMemberExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kUnresolvedMemberExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UnresolvedUsingIfExistsDecl.cpp b/lib/AST/UnresolvedUsingIfExistsDecl.cpp
index 09a9eb96e..86a0a283c 100644
--- a/lib/AST/UnresolvedUsingIfExistsDecl.cpp
+++ b/lib/AST/UnresolvedUsingIfExistsDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool UnresolvedUsingIfExistsDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UnresolvedUsingIfExistsDecl> UnresolvedUsingIfExistsDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UnresolvedUsingIfExistsDecl, ir::Operation>> UnresolvedUsingIfExistsDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kUnresolvedUsingIfExistsDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UnresolvedUsingIfExistsDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UnresolvedUsingIfExistsDecl> UnresolvedUsingIfExistsDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kUnresolvedUsingIfExistsDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UnresolvedUsingTypenameDecl.cpp b/lib/AST/UnresolvedUsingTypenameDecl.cpp
index 3cb8d670f..b6b175fb6 100644
--- a/lib/AST/UnresolvedUsingTypenameDecl.cpp
+++ b/lib/AST/UnresolvedUsingTypenameDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/TypeDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool UnresolvedUsingTypenameDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UnresolvedUsingTypenameDecl> UnresolvedUsingTypenameDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UnresolvedUsingTypenameDecl, ir::Operation>> UnresolvedUsingTypenameDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kUnresolvedUsingTypenameDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UnresolvedUsingTypenameDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UnresolvedUsingTypenameDecl> UnresolvedUsingTypenameDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kUnresolvedUsingTypenameDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UnresolvedUsingValueDecl.cpp b/lib/AST/UnresolvedUsingValueDecl.cpp
index 0bcbea97a..6aaa2c29d 100644
--- a/lib/AST/UnresolvedUsingValueDecl.cpp
+++ b/lib/AST/UnresolvedUsingValueDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool UnresolvedUsingValueDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UnresolvedUsingValueDecl> UnresolvedUsingValueDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UnresolvedUsingValueDecl, ir::Operation>> UnresolvedUsingValueDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kUnresolvedUsingValueDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UnresolvedUsingValueDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UnresolvedUsingValueDecl> UnresolvedUsingValueDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kUnresolvedUsingValueDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UserDefinedLiteral.cpp b/lib/AST/UserDefinedLiteral.cpp
index 9bcedaf07..354dc51fc 100644
--- a/lib/AST/UserDefinedLiteral.cpp
+++ b/lib/AST/UserDefinedLiteral.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool UserDefinedLiteral::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UserDefinedLiteral> UserDefinedLiteral::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UserDefinedLiteral, ir::Operation>> UserDefinedLiteral::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kUserDefinedLiteralDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UserDefinedLiteral, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UserDefinedLiteral> UserDefinedLiteral::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kUserDefinedLiteralDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UsingDecl.cpp b/lib/AST/UsingDecl.cpp
index 99926acd9..b46309be4 100644
--- a/lib/AST/UsingDecl.cpp
+++ b/lib/AST/UsingDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool UsingDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UsingDecl> UsingDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UsingDecl, ir::Operation>> UsingDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kUsingDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UsingDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UsingDecl> UsingDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kUsingDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UsingDirectiveDecl.cpp b/lib/AST/UsingDirectiveDecl.cpp
index 98372fa0a..b3c741b2d 100644
--- a/lib/AST/UsingDirectiveDecl.cpp
+++ b/lib/AST/UsingDirectiveDecl.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -82,17 +80,10 @@ bool UsingDirectiveDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UsingDirectiveDecl> UsingDirectiveDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UsingDirectiveDecl, ir::Operation>> UsingDirectiveDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kUsingDirectiveDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UsingDirectiveDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UsingDirectiveDecl> UsingDirectiveDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kUsingDirectiveDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UsingEnumDecl.cpp b/lib/AST/UsingEnumDecl.cpp
index c7aa2551b..dc5e6f333 100644
--- a/lib/AST/UsingEnumDecl.cpp
+++ b/lib/AST/UsingEnumDecl.cpp
@@ -15,8 +15,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/Type.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool UsingEnumDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UsingEnumDecl> UsingEnumDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UsingEnumDecl, ir::Operation>> UsingEnumDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kUsingEnumDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UsingEnumDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UsingEnumDecl> UsingEnumDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kUsingEnumDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UsingPackDecl.cpp b/lib/AST/UsingPackDecl.cpp
index c1932ed18..605355634 100644
--- a/lib/AST/UsingPackDecl.cpp
+++ b/lib/AST/UsingPackDecl.cpp
@@ -12,8 +12,6 @@
 #include <multiplier/AST/Stmt.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -81,17 +79,10 @@ bool UsingPackDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UsingPackDecl> UsingPackDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UsingPackDecl, ir::Operation>> UsingPackDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kUsingPackDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UsingPackDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UsingPackDecl> UsingPackDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kUsingPackDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/UsingShadowDecl.cpp b/lib/AST/UsingShadowDecl.cpp
index e990afd42..906dd855b 100644
--- a/lib/AST/UsingShadowDecl.cpp
+++ b/lib/AST/UsingShadowDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ConstructorUsingShadowDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -84,17 +82,10 @@ bool UsingShadowDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<UsingShadowDecl> UsingShadowDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<UsingShadowDecl, ir::Operation>> UsingShadowDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kUsingShadowDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<UsingShadowDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<UsingShadowDecl> UsingShadowDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kUsingShadowDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/VAArgExpr.cpp b/lib/AST/VAArgExpr.cpp
index 0bd4f8a71..5b7fc2159 100644
--- a/lib/AST/VAArgExpr.cpp
+++ b/lib/AST/VAArgExpr.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/ValueStmt.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -82,17 +80,10 @@ bool VAArgExpr::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<VAArgExpr> VAArgExpr::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<VAArgExpr, ir::Operation>> VAArgExpr::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kVAArgExprDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<VAArgExpr, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<VAArgExpr> VAArgExpr::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kVAArgExprDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ValueDecl.cpp b/lib/AST/ValueDecl.cpp
index 554f3d595..c8c6384fe 100644
--- a/lib/AST/ValueDecl.cpp
+++ b/lib/AST/ValueDecl.cpp
@@ -41,8 +41,6 @@
 #include <multiplier/AST/VarTemplatePartialSpecializationDecl.h>
 #include <multiplier/AST/VarTemplateSpecializationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -136,17 +134,10 @@ bool ValueDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ValueDecl> ValueDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ValueDecl, ir::Operation>> ValueDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kValueDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ValueDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ValueDecl> ValueDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kValueDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/ValueStmt.cpp b/lib/AST/ValueStmt.cpp
index 540e7ba6a..590e2b1a4 100644
--- a/lib/AST/ValueStmt.cpp
+++ b/lib/AST/ValueStmt.cpp
@@ -138,8 +138,6 @@
 #include <multiplier/AST/UserDefinedLiteral.h>
 #include <multiplier/AST/VAArgExpr.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -332,17 +330,10 @@ bool ValueStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<ValueStmt> ValueStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<ValueStmt, ir::Operation>> ValueStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kValueStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<ValueStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<ValueStmt> ValueStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kValueStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/VarDecl.cpp b/lib/AST/VarDecl.cpp
index 3b618656d..bc4af352d 100644
--- a/lib/AST/VarDecl.cpp
+++ b/lib/AST/VarDecl.cpp
@@ -22,8 +22,6 @@
 #include <multiplier/AST/VarTemplatePartialSpecializationDecl.h>
 #include <multiplier/AST/VarTemplateSpecializationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -97,17 +95,10 @@ bool VarDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<VarDecl> VarDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<VarDecl, ir::Operation>> VarDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kVarDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<VarDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<VarDecl> VarDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kVarDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/VarTemplateDecl.cpp b/lib/AST/VarTemplateDecl.cpp
index 384cb6542..d44d33bec 100644
--- a/lib/AST/VarTemplateDecl.cpp
+++ b/lib/AST/VarTemplateDecl.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/AST/TemplateDecl.h>
 #include <multiplier/Frontend/Token.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -83,17 +81,10 @@ bool VarTemplateDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<VarTemplateDecl> VarTemplateDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<VarTemplateDecl, ir::Operation>> VarTemplateDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kVarTemplateDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<VarTemplateDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<VarTemplateDecl> VarTemplateDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kVarTemplateDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/VarTemplatePartialSpecializationDecl.cpp b/lib/AST/VarTemplatePartialSpecializationDecl.cpp
index 256046175..5494d4b44 100644
--- a/lib/AST/VarTemplatePartialSpecializationDecl.cpp
+++ b/lib/AST/VarTemplatePartialSpecializationDecl.cpp
@@ -17,8 +17,6 @@
 #include <multiplier/AST/VarDecl.h>
 #include <multiplier/AST/VarTemplateSpecializationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -86,17 +84,10 @@ bool VarTemplatePartialSpecializationDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<VarTemplatePartialSpecializationDecl> VarTemplatePartialSpecializationDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<VarTemplatePartialSpecializationDecl, ir::Operation>> VarTemplatePartialSpecializationDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kVarTemplatePartialSpecializationDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<VarTemplatePartialSpecializationDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<VarTemplatePartialSpecializationDecl> VarTemplatePartialSpecializationDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kVarTemplatePartialSpecializationDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/VarTemplateSpecializationDecl.cpp b/lib/AST/VarTemplateSpecializationDecl.cpp
index bc156582d..9f1458d83 100644
--- a/lib/AST/VarTemplateSpecializationDecl.cpp
+++ b/lib/AST/VarTemplateSpecializationDecl.cpp
@@ -18,8 +18,6 @@
 #include <multiplier/AST/VarTemplateDecl.h>
 #include <multiplier/AST/VarTemplatePartialSpecializationDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Decl.h"
 
@@ -88,17 +86,10 @@ bool VarTemplateSpecializationDecl::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<VarTemplateSpecializationDecl> VarTemplateSpecializationDecl::from(const ir::Operation &op) {
-  if (auto val = Decl::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<VarTemplateSpecializationDecl, ir::Operation>> VarTemplateSpecializationDecl::in(const Compilation &tu) {
-  for (std::pair<Decl, ir::Operation> res : Decl::in(tu, kVarTemplateSpecializationDeclDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<VarTemplateSpecializationDecl, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<VarTemplateSpecializationDecl> VarTemplateSpecializationDecl::in(const Compilation &tu) {
+  for (Decl res : Decl::in(tu, kVarTemplateSpecializationDeclDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/AST/WhileStmt.cpp b/lib/AST/WhileStmt.cpp
index 4ab91c9e1..a80afe136 100644
--- a/lib/AST/WhileStmt.cpp
+++ b/lib/AST/WhileStmt.cpp
@@ -14,8 +14,6 @@
 #include <multiplier/Frontend/Token.h>
 #include <multiplier/AST/VarDecl.h>
 
-#include <multiplier/IR/HighLevel/Operation.h>
-
 #include "../EntityProvider.h"
 #include "../Stmt.h"
 
@@ -83,17 +81,10 @@ bool WhileStmt::contains(const Token &tok) const {
   return false;
 }
 
-std::optional<WhileStmt> WhileStmt::from(const ir::Operation &op) {
-  if (auto val = Stmt::from(op)) {
-    return from_base(val.value());
-  }
-  return std::nullopt;
-}
-
-gap::generator<std::pair<WhileStmt, ir::Operation>> WhileStmt::in(const Compilation &tu) {
-  for (std::pair<Stmt, ir::Operation> res : Stmt::in(tu, kWhileStmtDerivedKinds)) {
-    if (auto val = from_base(res.first)) {
-      co_yield std::pair<WhileStmt, ir::Operation>(std::move(val.value()), std::move(res.second));
+gap::generator<WhileStmt> WhileStmt::in(const Compilation &tu) {
+  for (Stmt res : Stmt::in(tu, kWhileStmtDerivedKinds)) {
+    if (auto val = from_base(res)) {
+      co_yield val.value();
     }
   }
 }
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index a105286e3..391ed4948 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -20,11 +20,6 @@ file(GLOB frontend_sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_LIST_DIR}/Frontend
 file(GLOB ast_headers CONFIGURE_DEPENDS "${MX_BOOTSTRAP_INCLUDE_DIR}/AST/*.h")
 file(GLOB ast_sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_LIST_DIR}/AST/*.cpp")
 
-set(ir_source_include_dir "${PROJECT_SOURCE_DIR}/include/${lower_project_name}/IR")
-
-file(GLOB_RECURSE ir_sources CONFIGURE_DEPENDS RELATIVE_PATH "${CMAKE_CURRENT_LIST_DIR}" "*.cpp")
-file(GLOB_RECURSE ir_headers CONFIGURE_DEPENDS RELATIVE_PATH "${ir_source_include_dir}" "*.h")
-
 # Configure the version to include the git hash.
 #
 # TODO(pag): This only tracks the hash that was present at CMake configure time.
@@ -100,7 +95,6 @@ set(api_headers
   "${source_include_dir}/Entity.h"
   "${source_include_dir}/Fragment.h"
   "${source_include_dir}/Index.h"
-  "${source_include_dir}/IR.h"  # Auto-generated.
   "${source_include_dir}/Iterator.h"
   "${source_include_dir}/Re2.h"
   "${source_include_dir}/Reference.h"
@@ -113,7 +107,6 @@ add_library("mx-api" OBJECT
 
   ${frontend_sources}  # Auto-generated
   ${ast_sources}  # Auto-generated
-  ${ir_sources}  # Auto-generated
 
   $<BUILD_INTERFACE:${source_include_dir}/Database.h>
   $<BUILD_INTERFACE:${MX_BOOTSTRAP_INCLUDE_VISITOR_INC_H}>
@@ -197,13 +190,6 @@ target_link_libraries("mx-api"
     "mx-sqlite"
     "zstd::libzstd_static"
     "concurrentqueue"
-    ${MLIR_LIBS}
-    ${VAST_LIBS}
-)
-
-target_link_directories("mx-api"
-  PRIVATE
-    "$<BUILD_INTERFACE:${MLIR_LIB_DIR}>"
 )
 
 target_compile_definitions("mx-api"
@@ -239,7 +225,7 @@ target_include_directories("mx-api"
     $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>
     $<INSTALL_INTERFACE:${MX_INSTALL_INCLUDE_DIR}>
   PRIVATE
-    "$<BUILD_INTERFACE:${LLVM_INCLUDE_DIRS};${LLVM_INCLUDE_DIR};${MLIR_INCLUDE_DIRS}>"
+    "$<BUILD_INTERFACE:${LLVM_INCLUDE_DIRS};${LLVM_INCLUDE_DIR}>"
     "${CMAKE_CURRENT_SOURCE_DIR}"
     "${CMAKE_CURRENT_BINARY_DIR}"
 )
@@ -329,12 +315,6 @@ if(MX_ENABLE_INSTALL AND NOT MX_ENABLE_BOOTSTRAP)
     DESTINATION
       "${MX_INSTALL_INCLUDE_DIR}/${lower_project_name}"
   )
-  install(
-    DIRECTORY
-      "${ir_source_include_dir}"
-    DESTINATION
-      "${MX_INSTALL_INCLUDE_DIR}/multiplier"
-  )
   install(
     TARGETS
       "multiplier"
diff --git a/lib/CachingEntityProvider.cpp b/lib/CachingEntityProvider.cpp
index 4f62db367..434e7906d 100644
--- a/lib/CachingEntityProvider.cpp
+++ b/lib/CachingEntityProvider.cpp
@@ -281,8 +281,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
-                            MX_DECLARE_ENTITY_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY)
+                            MX_DECLARE_ENTITY_GETTER)
 #undef MX_DECLARE_ENTITY_GETTER
 
 #define MX_DECLARE_ENTITY_LISTERS(ns_path, type_name, lower_name, enum_name, category) \
@@ -297,7 +296,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_DECLARE_ENTITY_LISTERS,
                             MX_IGNORE_ENTITY_CATEGORY,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_ENTITY_LISTERS
 
diff --git a/lib/CachingEntityProvider.h b/lib/CachingEntityProvider.h
index 94fd52ec1..a1265d5aa 100644
--- a/lib/CachingEntityProvider.h
+++ b/lib/CachingEntityProvider.h
@@ -45,8 +45,7 @@ class CachingEntityProvider final : public EntityProvider {
                               DECLARE_ENTITY_CACHE,
                               DECLARE_ENTITY_CACHE,
                               DECLARE_ENTITY_CACHE,
-                              DECLARE_ENTITY_CACHE,
-                              MX_IGNORE_ENTITY_CATEGORY)
+                              DECLARE_ENTITY_CACHE)
 #undef DECLARE_ENTITY_CACHE
 
   // Cached list of fragments inside of files.
@@ -127,8 +126,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
-                            MX_DECLARE_ENTITY_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY)
+                            MX_DECLARE_ENTITY_GETTER)
 #undef MX_DECLARE_ENTITY_GETTER
 
 #define MX_DECLARE_ENTITY_LISTERS(ns_path, type_name, lower_name, enum_name, category) \
@@ -141,7 +139,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_DECLARE_ENTITY_LISTERS,
                             MX_IGNORE_ENTITY_CATEGORY,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_ENTITY_LISTERS
 };
diff --git a/lib/Compilation.cpp b/lib/Compilation.cpp
index 4e2550963..6ac122499 100644
--- a/lib/Compilation.cpp
+++ b/lib/Compilation.cpp
@@ -8,9 +8,7 @@
 #include <multiplier/Fragment.h>
 #include <multiplier/Frontend/DefineMacroDirective.h>
 #include <multiplier/Frontend/IncludePathLocation.h>
-#include <multiplier/IR/Builtin/Operation.h>
 
-#include "IR/SourceIR.h"
 #include "Reference.h"
 #include "Token.h"
 
@@ -31,31 +29,6 @@ CompilationImpl::CompilationImpl(
     : EntityImpl<rpc::Compilation>(std::move(ep_), kj::mv(data_)),
       compilation_id(EntityId(id_).Extract<CompilationId>().value()) {}
 
-std::string_view CompilationImpl::SourceIR(void) const & noexcept {
-  if (reader.hasMlir()) {
-    if (auto mlir = reader.getMlir(); auto size = mlir.size()) {
-      return std::string_view(mlir.cStr(), size);
-    }
-  }
-  return kEmptyStringView;
-}
-
-// Return a pointer to the source IR object.
-std::shared_ptr<const ir::SourceIRImpl>
-CompilationImpl::SourceIRPtr(PackedCompilationId id) const & noexcept {
-  std::unique_lock<std::mutex> locker(source_ir_lock);
-
-  auto ir_obj = source_ir.lock();
-  if (!ir_obj) {
-    if (auto mlir = SourceIR(); !mlir.empty()) {
-      ir_obj = std::make_shared<const ir::SourceIRImpl>(id, ep, mlir);
-      source_ir = ir_obj;
-    }
-  }
-
-  return ir_obj;
-}
-
 PackedCompilationId Compilation::id(void) const noexcept {
   return impl->compilation_id;
 }
@@ -365,16 +338,4 @@ Compilation::framework_directories(void) const & {
   }
 }
 
-// Returns source IR for the compilation.
-std::optional<ir::builtin::ModuleOp> Compilation::ir(void) const noexcept {
-  if (auto ir_obj = impl->SourceIRPtr(id())) {
-    if (mlir::Operation *ptr = ir_obj->scope()) {
-      ir::Operation op(std::move(ir_obj), ptr);
-      return ir::builtin::ModuleOp::from(op);
-    }
-  }
-
-  return std::nullopt;
-}
-
 }  // namespace mx
diff --git a/lib/Compilation.h b/lib/Compilation.h
index c57383c2e..e898b45b9 100644
--- a/lib/Compilation.h
+++ b/lib/Compilation.h
@@ -11,17 +11,8 @@
 #include "EntityProvider.h"
 
 namespace mx {
-namespace ir {
-class SourceIRImpl;
-}  // namespace ir
 
 class CompilationImpl final : public EntityImpl<rpc::Compilation> {
- private:
-  friend class ir::SourceIRImpl;
-
-  mutable std::mutex source_ir_lock;
-  mutable std::weak_ptr<const ir::SourceIRImpl> source_ir;
-
  public:
   using Ptr = CompilationImplPtr;
   using WeakPtr = WeakCompilationImplPtr;
@@ -34,13 +25,6 @@ class CompilationImpl final : public EntityImpl<rpc::Compilation> {
 
   explicit CompilationImpl(EntityProviderPtr ep_, kj::Array<capnp::word> data_,
                            RawEntityId id_);
-
-  // Return the source ir for the compilation.
-  std::string_view SourceIR(void) const & noexcept;
-
-  // Return a pointer to the source IR object.
-  std::shared_ptr<const ir::SourceIRImpl> SourceIRPtr(
-      PackedCompilationId id) const & noexcept;
 };
 
 }  // namespace mx
diff --git a/lib/Database.cpp b/lib/Database.cpp
index ae9c5d9b9..0ac558c91 100644
--- a/lib/Database.cpp
+++ b/lib/Database.cpp
@@ -172,7 +172,6 @@ class BulkInserterState {
       MX_IGNORE_ENTITY_CATEGORY,
       CREATE_FRAG_OFFSET_INDEX,
       CREATE_PSEUDO_INDEX,
-      MX_IGNORE_ENTITY_CATEGORY,
       MX_IGNORE_ENTITY_CATEGORY)
 
 #undef CREATE_FRAG_OFFSET_INDEX
@@ -767,7 +766,6 @@ std::filesystem::path CreateDatabase(const std::filesystem::path &db_path_) {
       MX_IGNORE_ENTITY_CATEGORY,
       CREATE_FRAG_OFFSET_INDEX,
       CREATE_PSEUDO_INDEX,
-      MX_IGNORE_ENTITY_CATEGORY,
       MX_IGNORE_ENTITY_CATEGORY)
 
 #undef CREATE_FRAG_OFFSET_INDEX
diff --git a/lib/Decl.cpp b/lib/Decl.cpp
index 38405b426..0488dd97b 100644
--- a/lib/Decl.cpp
+++ b/lib/Decl.cpp
@@ -5,6 +5,7 @@
 
 #include "Decl.h"
 
+#include <algorithm>
 #include <multiplier/AST/ClassTemplateDecl.h>
 #include <multiplier/AST/ClassTemplatePartialSpecializationDecl.h>
 #include <multiplier/AST/CXXMethodDecl.h>
@@ -746,4 +747,25 @@ TokenRange NamedDecl::qualified_name(
   return TokenRange(std::move(tr), 0u, num_tokens);
 }
 
+gap::generator<Decl> Decl::in(const Compilation &tu) {
+  auto frags = tu.fragments();
+  for (Fragment frag : frags) {
+    for (Decl decl : Decl::in(frag)) {
+      co_yield std::move(decl);
+    }
+  }
+}
+
+gap::generator<Decl> Decl::in(const Compilation &tu,
+                              std::span<const DeclKind> kinds) {
+  auto frags = tu.fragments();
+  for (Fragment frag : frags) {
+    for (Decl decl : Decl::in(frag)) {
+      if (std::find(kinds.begin(), kinds.end(), decl.kind()) != kinds.end()) {
+        co_yield std::move(decl);
+      }
+    }
+  }
+}
+
 }  // namespace mx
diff --git a/lib/EntityProvider.cpp b/lib/EntityProvider.cpp
index 75aae2f1f..476ba4cd2 100644
--- a/lib/EntityProvider.cpp
+++ b/lib/EntityProvider.cpp
@@ -388,7 +388,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_DECLARE_FRAGMENT_OFFSET_LISTERS,
                             MX_DECLARE_FRAGMENT_PSEUDO_LISTERS,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_FRAGMENT_OFFSET_LISTERS
 #undef MX_DECLARE_FRAGMENT_PSEUDO_LISTERS
diff --git a/lib/EntityProvider.h b/lib/EntityProvider.h
index 9e7bd8df7..045a24894 100644
--- a/lib/EntityProvider.h
+++ b/lib/EntityProvider.h
@@ -127,8 +127,7 @@ class EntityProvider {
                               MX_DECLARE_ENTITY_GETTER,
                               MX_DECLARE_ENTITY_GETTER,
                               MX_DECLARE_ENTITY_GETTER,
-                              MX_DECLARE_ENTITY_GETTER,
-                              MX_IGNORE_ENTITY_CATEGORY)
+                              MX_DECLARE_ENTITY_GETTER)
 #undef MX_DECLARE_ENTITY_GETTER
 
 #define MX_DECLARE_ENTITY_LISTERS(ns_path, type_name, lower_name, enum_name, category) \
@@ -141,7 +140,6 @@ class EntityProvider {
                               MX_IGNORE_ENTITY_CATEGORY,
                               MX_DECLARE_ENTITY_LISTERS,
                               MX_IGNORE_ENTITY_CATEGORY,
-                              MX_IGNORE_ENTITY_CATEGORY,
                               MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_ENTITY_LISTERS
 
@@ -155,7 +153,6 @@ class EntityProvider {
                               MX_IGNORE_ENTITY_CATEGORY,
                               MX_DECLARE_ENTITY_LISTERS,
                               MX_IGNORE_ENTITY_CATEGORY,
-                              MX_IGNORE_ENTITY_CATEGORY,
                               MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_ENTITY_LISTERS
 
@@ -169,7 +166,6 @@ class EntityProvider {
                               MX_IGNORE_ENTITY_CATEGORY,
                               MX_DECLARE_ENTITY_LISTERS,
                               MX_DECLARE_ENTITY_LISTERS,
-                              MX_IGNORE_ENTITY_CATEGORY,
                               MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_ENTITY_LISTERS
 
diff --git a/lib/File.cpp b/lib/File.cpp
index 1930fa01a..18cfc5963 100644
--- a/lib/File.cpp
+++ b/lib/File.cpp
@@ -11,7 +11,6 @@
 #include <multiplier/AST/Type.h>
 #include <multiplier/Frontend/Macro.h>
 #include <multiplier/Frontend/Query.h>
-#include <multiplier/IR/Operation.h>
 #include <mutex>
 
 #include "Attr.h"
@@ -245,21 +244,9 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_DEFINE_CONTAINING,
                             MX_DEFINE_CONTAINING,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DEFINE_CONTAINING
 
-// Return the file containing an operation.
-std::optional<File> File::containing(const ir::Operation &op) noexcept {
-  if (auto decl = Decl::from(op)) {
-    return File::containing(decl.value());
-  } else if (auto stmt = Stmt::from(op)) {
-    return File::containing(stmt.value());
-  } else {
-    return std::nullopt;
-  }
-}
-
 std::optional<File> File::containing(const VariantEntity &entity) noexcept {
 #define GET_FILE(ns_path, type_name, lower_name, enum_name, category) \
     if (auto lower_name ## _ptr = std::get_if<ns_path type_name>(&entity)) { \
@@ -268,7 +255,7 @@ std::optional<File> File::containing(const VariantEntity &entity) noexcept {
 
   MX_FOR_EACH_ENTITY_CATEGORY(GET_FILE, GET_FILE, MX_IGNORE_ENTITY_CATEGORY,
                               GET_FILE, GET_FILE, GET_FILE,
-                              MX_IGNORE_ENTITY_CATEGORY, GET_FILE)
+                              MX_IGNORE_ENTITY_CATEGORY)
   return std::nullopt;
 #undef GET_FILE
 }
diff --git a/lib/Fragment.cpp b/lib/Fragment.cpp
index f18267c4d..a28dc3e25 100644
--- a/lib/Fragment.cpp
+++ b/lib/Fragment.cpp
@@ -26,9 +26,6 @@
 #include "Type.h"
 
 namespace mx {
-namespace ir {
-class SourceIRImpl;
-}  // namespace ir
 
 std::optional<Fragment> Fragment::containing(const Fragment &child) noexcept {
   auto parent_id = child.impl->parent_fragment_id;
@@ -121,18 +118,6 @@ std::optional<Fragment> Fragment::containing(const Token &entity) noexcept {
   }
 }
 
-// Return the fragment containing an operation.
-std::optional<Fragment> Fragment::containing(
-    const ir::Operation &op) noexcept {
-  if (auto decl = Decl::from(op)) {
-    return Fragment::containing(decl.value());
-  } else if (auto stmt = Stmt::from(op)) {
-    return Fragment::containing(stmt.value());
-  }
-
-  return std::nullopt;
-}
-
 std::optional<Fragment> Fragment::containing(
     const VariantEntity &entity) noexcept {
 #define GET_FRAGMENT(ns_path, type_name, lower_name, enum_name, category) \
@@ -148,8 +133,7 @@ std::optional<Fragment> Fragment::containing(
                               GET_FRAGMENT,
                               GET_FRAGMENT,
                               GET_FRAGMENT,
-                              MX_IGNORE_ENTITY_CATEGORY,
-                              GET_FRAGMENT)
+                              MX_IGNORE_ENTITY_CATEGORY)
   return std::nullopt;
 #undef GET_FRAGMENT
 }
diff --git a/lib/Fragment.h b/lib/Fragment.h
index b8c6bccf7..a3f94ada8 100644
--- a/lib/Fragment.h
+++ b/lib/Fragment.h
@@ -9,9 +9,6 @@
 #include "TokenTree.h"
 
 namespace mx {
-namespace ir {
-class SourceIRImpl;
-}  // namespace ir
 
 class FileImpl;
 
diff --git a/lib/IR/ABI/Operation.cpp b/lib/IR/ABI/Operation.cpp
deleted file mode 100644
index 7206eb6c7..000000000
--- a/lib/IR/ABI/Operation.cpp
+++ /dev/null
@@ -1,459 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/ABI/Operation.h>
-
-#include <multiplier/IR/Attribute.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Type.h>
-
-#include <ios>
-#include <string>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/ABI/ABIOps.hpp>
-
-namespace mx::ir::abi {
-std::optional<Operation> Operation::from(const ::mx::ir::Operation &that) {
-  if (IsABIOperationKind(that.kind())) {
-    return reinterpret_cast<const Operation &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CallArgsOp> CallArgsOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_CALL_ARGS) {
-    return reinterpret_cast<const CallArgsOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CallArgsOp> CallArgsOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::CallArgsOp CallArgsOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::CallArgsOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Result> CallArgsOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Region CallArgsOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<CallExecutionOp> CallExecutionOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_CALL_EXEC) {
-    return reinterpret_cast<const CallExecutionOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CallExecutionOp> CallExecutionOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::CallExecutionOp CallExecutionOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::CallExecutionOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> CallExecutionOp::arguments(void) const & {
-  auto range = underlying_repr().getArgs();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value CallExecutionOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region CallExecutionOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-gap::generator<::mx::ir::Operand> CallExecutionOp::arg_operands(void) const & {
-  auto range = underlying_repr().getArgOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<CallOp> CallOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_CALL) {
-    return reinterpret_cast<const CallOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CallOp> CallOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::CallOp CallOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::CallOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> CallOp::arguments(void) const & {
-  auto range = underlying_repr().getArgs();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Result> CallOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::string_view CallOp::callee(void) const {
-  auto val = underlying_repr().getCallee();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-gap::generator<::mx::ir::Operand> CallOp::arg_operands(void) const & {
-  auto range = underlying_repr().getArgOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<CallRetsOp> CallRetsOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_CALL_RETS) {
-    return reinterpret_cast<const CallRetsOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CallRetsOp> CallRetsOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::CallRetsOp CallRetsOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::CallRetsOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Result> CallRetsOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Region CallRetsOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<DirectOp> DirectOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_DIRECT) {
-    return reinterpret_cast<const DirectOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DirectOp> DirectOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::DirectOp DirectOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::DirectOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> DirectOp::value(void) const & {
-  auto range = underlying_repr().getValue();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Result> DirectOp::result(void) const & {
-  auto range = underlying_repr().getResult();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<EpilogueOp> EpilogueOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_EPILOGUE) {
-    return reinterpret_cast<const EpilogueOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<EpilogueOp> EpilogueOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::EpilogueOp EpilogueOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::EpilogueOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Result> EpilogueOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Region EpilogueOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<FuncOp> FuncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_FUNC) {
-    return reinterpret_cast<const FuncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FuncOp> FuncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::FuncOp FuncOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::FuncOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<::mx::ir::Region> FuncOp::body(void) const {
-  decltype(auto) opt_val = underlying_repr().getBody();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view FuncOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type FuncOp::function_type(void) const {
-  auto mlir_type = underlying_repr().getFunctionType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<std::string_view> FuncOp::visibility(void) const {
-  auto opt_val = underlying_repr().getSymVisibility();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool FuncOp::is_var_arg(void) const {
-  auto val = underlying_repr().isVarArg();
-  return val;
-}
-
-gap::generator<::mx::ir::Type> FuncOp::callable_results(void) const & {
-  auto range = underlying_repr().getCallableResults();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-gap::generator<::mx::ir::Type> FuncOp::argument_types(void) const & {
-  auto range = underlying_repr().getArgumentTypes();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-gap::generator<::mx::ir::Type> FuncOp::result_types(void) const & {
-  auto range = underlying_repr().getResultTypes();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-bool FuncOp::is_declaration(void) const {
-  auto val = underlying_repr().isDeclaration();
-  return val;
-}
-
-std::optional<IndirectOp> IndirectOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_INDIRECT) {
-    return reinterpret_cast<const IndirectOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<IndirectOp> IndirectOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::IndirectOp IndirectOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::IndirectOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value IndirectOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value IndirectOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PrologueOp> PrologueOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_PROLOGUE) {
-    return reinterpret_cast<const PrologueOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PrologueOp> PrologueOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::PrologueOp PrologueOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::PrologueOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Result> PrologueOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Region PrologueOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<RetDirectOp> RetDirectOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_RET_DIRECT) {
-    return reinterpret_cast<const RetDirectOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RetDirectOp> RetDirectOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::RetDirectOp RetDirectOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::RetDirectOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RetDirectOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Result> RetDirectOp::result(void) const & {
-  auto range = underlying_repr().getResult();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<YieldOp> YieldOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::ABI_YIELD) {
-    return reinterpret_cast<const YieldOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<YieldOp> YieldOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::abi::YieldOp YieldOp::underlying_repr(void) const noexcept {
-  return ::vast::abi::YieldOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> YieldOp::values(void) const & {
-  auto range = underlying_repr().getValues();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Result> YieldOp::result(void) const & {
-  auto range = underlying_repr().getResult();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-}  // namespace mx::ir::abi
diff --git a/lib/IR/Attribute.h b/lib/IR/Attribute.h
deleted file mode 100644
index d34509e6a..000000000
--- a/lib/IR/Attribute.h
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#pragma once
-
-#define MX_IR_FOR_EACH_MLIR_ATTRIBUTE(_builtin, _llvm, _memref, _abi, _ll, _hl, _core, _meta, _unsup) \
-   _builtin(TypedAttr, AttributeKind::BUILTIN_TYPED, mlir::TypedAttr) \
-   _builtin(ElementsAttr, AttributeKind::BUILTIN_ELEMENTS, mlir::ElementsAttr) \
-   _builtin(AffineMapAttr, AttributeKind::BUILTIN_AFFINE_MAP, mlir::AffineMapAttr) \
-   _builtin(ArrayAttr, AttributeKind::BUILTIN_ARRAY, mlir::ArrayAttr) \
-   _builtin(DenseArrayAttr, AttributeKind::BUILTIN_DENSE_ARRAY, mlir::DenseArrayAttr) \
-   _builtin(DenseIntOrFPElementsAttr, AttributeKind::BUILTIN_DENSE_INT_OR_FP_ELEMENTS, mlir::DenseIntOrFPElementsAttr) \
-   _builtin(DenseStringElementsAttr, AttributeKind::BUILTIN_DENSE_STRING_ELEMENTS, mlir::DenseStringElementsAttr) \
-   _builtin(DenseResourceElementsAttr, AttributeKind::BUILTIN_DENSE_RESOURCE_ELEMENTS, mlir::DenseResourceElementsAttr) \
-   _builtin(DictionaryAttr, AttributeKind::BUILTIN_DICTIONARY, mlir::DictionaryAttr) \
-   _builtin(FloatAttr, AttributeKind::BUILTIN_FLOAT, mlir::FloatAttr) \
-   _builtin(IntegerAttr, AttributeKind::BUILTIN_INTEGER, mlir::IntegerAttr) \
-   _builtin(IntegerSetAttr, AttributeKind::BUILTIN_INTEGER_SET, mlir::IntegerSetAttr) \
-   _builtin(OpaqueAttr, AttributeKind::BUILTIN_OPAQUE, mlir::OpaqueAttr) \
-   _builtin(SparseElementsAttr, AttributeKind::BUILTIN_SPARSE_ELEMENTS, mlir::SparseElementsAttr) \
-   _builtin(StridedLayoutAttr, AttributeKind::BUILTIN_STRIDED_LAYOUT, mlir::StridedLayoutAttr) \
-   _builtin(StringAttr, AttributeKind::BUILTIN_STRING, mlir::StringAttr) \
-   _builtin(SymbolRefAttr, AttributeKind::BUILTIN_SYMBOL_REF, mlir::SymbolRefAttr) \
-   _builtin(TypeAttr, AttributeKind::BUILTIN_TYPE, mlir::TypeAttr) \
-   _builtin(UnitAttr, AttributeKind::BUILTIN_UNIT, mlir::UnitAttr) \
-   _builtin(BoolAttr, AttributeKind::BUILTIN_BOOL, mlir::BoolAttr) \
-   _builtin(FlatSymbolRefAttr, AttributeKind::BUILTIN_FLAT_SYMBOL_REF, mlir::FlatSymbolRefAttr) \
-   _builtin(DenseIntElementsAttr, AttributeKind::BUILTIN_DENSE_INT_ELEMENTS, mlir::DenseIntElementsAttr) \
-   _builtin(DataLayoutSpecAttr, AttributeKind::BUILTIN_DATA_LAYOUT_SPEC, mlir::DataLayoutSpecAttr) \
-   _llvm(CConvAttr, AttributeKind::LLVM_C_CONV, mlir::LLVM::CConvAttr) \
-   _llvm(ComdatAttr, AttributeKind::LLVM_COMDAT, mlir::LLVM::ComdatAttr) \
-   _llvm(LinkageAttr, AttributeKind::LLVM_LINKAGE, mlir::LLVM::LinkageAttr) \
-   _llvm(FramePointerKindAttr, AttributeKind::LLVM_FRAME_POINTER_KIND, mlir::LLVM::FramePointerKindAttr) \
-   _llvm(LoopVectorizeAttr, AttributeKind::LLVM_LOOP_VECTORIZE, mlir::LLVM::LoopVectorizeAttr) \
-   _llvm(LoopInterleaveAttr, AttributeKind::LLVM_LOOP_INTERLEAVE, mlir::LLVM::LoopInterleaveAttr) \
-   _llvm(LoopUnrollAttr, AttributeKind::LLVM_LOOP_UNROLL, mlir::LLVM::LoopUnrollAttr) \
-   _llvm(LoopUnrollAndJamAttr, AttributeKind::LLVM_LOOP_UNROLL_AND_JAM, mlir::LLVM::LoopUnrollAndJamAttr) \
-   _llvm(LoopLICMAttr, AttributeKind::LLVM_LOOP_LICM, mlir::LLVM::LoopLICMAttr) \
-   _llvm(LoopDistributeAttr, AttributeKind::LLVM_LOOP_DISTRIBUTE, mlir::LLVM::LoopDistributeAttr) \
-   _llvm(LoopPipelineAttr, AttributeKind::LLVM_LOOP_PIPELINE, mlir::LLVM::LoopPipelineAttr) \
-   _llvm(LoopPeeledAttr, AttributeKind::LLVM_LOOP_PEELED, mlir::LLVM::LoopPeeledAttr) \
-   _llvm(LoopUnswitchAttr, AttributeKind::LLVM_LOOP_UNSWITCH, mlir::LLVM::LoopUnswitchAttr) \
-   _llvm(LoopAnnotationAttr, AttributeKind::LLVM_LOOP_ANNOTATION, mlir::LLVM::LoopAnnotationAttr) \
-   _llvm(DIExpressionElemAttr, AttributeKind::LLVM_DI_EXPRESSION_ELEM, mlir::LLVM::DIExpressionElemAttr) \
-   _llvm(DIExpressionAttr, AttributeKind::LLVM_DI_EXPRESSION, mlir::LLVM::DIExpressionAttr) \
-   _llvm(DINullTypeAttr, AttributeKind::LLVM_DI_NULL_TYPE, mlir::LLVM::DINullTypeAttr) \
-   _llvm(DIBasicTypeAttr, AttributeKind::LLVM_DI_BASIC_TYPE, mlir::LLVM::DIBasicTypeAttr) \
-   _llvm(DICompileUnitAttr, AttributeKind::LLVM_DI_COMPILE_UNIT, mlir::LLVM::DICompileUnitAttr) \
-   _llvm(DICompositeTypeAttr, AttributeKind::LLVM_DI_COMPOSITE_TYPE, mlir::LLVM::DICompositeTypeAttr) \
-   _llvm(DIDerivedTypeAttr, AttributeKind::LLVM_DI_DERIVED_TYPE, mlir::LLVM::DIDerivedTypeAttr) \
-   _llvm(DIFileAttr, AttributeKind::LLVM_DI_FILE, mlir::LLVM::DIFileAttr) \
-   _llvm(DIGlobalVariableExpressionAttr, AttributeKind::LLVM_DI_GLOBAL_VARIABLE_EXPRESSION, mlir::LLVM::DIGlobalVariableExpressionAttr) \
-   _llvm(DIGlobalVariableAttr, AttributeKind::LLVM_DI_GLOBAL_VARIABLE, mlir::LLVM::DIGlobalVariableAttr) \
-   _llvm(DILexicalBlockAttr, AttributeKind::LLVM_DI_LEXICAL_BLOCK, mlir::LLVM::DILexicalBlockAttr) \
-   _llvm(DILexicalBlockFileAttr, AttributeKind::LLVM_DI_LEXICAL_BLOCK_FILE, mlir::LLVM::DILexicalBlockFileAttr) \
-   _llvm(DILocalVariableAttr, AttributeKind::LLVM_DI_LOCAL_VARIABLE, mlir::LLVM::DILocalVariableAttr) \
-   _llvm(DISubprogramAttr, AttributeKind::LLVM_DI_SUBPROGRAM, mlir::LLVM::DISubprogramAttr) \
-   _llvm(DIModuleAttr, AttributeKind::LLVM_DI_MODULE, mlir::LLVM::DIModuleAttr) \
-   _llvm(DINamespaceAttr, AttributeKind::LLVM_DI_NAMESPACE, mlir::LLVM::DINamespaceAttr) \
-   _llvm(DISubrangeAttr, AttributeKind::LLVM_DI_SUBRANGE, mlir::LLVM::DISubrangeAttr) \
-   _llvm(DISubroutineTypeAttr, AttributeKind::LLVM_DI_SUBROUTINE_TYPE, mlir::LLVM::DISubroutineTypeAttr) \
-   _llvm(DILabelAttr, AttributeKind::LLVM_DI_LABEL, mlir::LLVM::DILabelAttr) \
-   _llvm(MemoryEffectsAttr, AttributeKind::LLVM_MEMORY_EFFECTS, mlir::LLVM::MemoryEffectsAttr) \
-   _llvm(AliasScopeDomainAttr, AttributeKind::LLVM_ALIAS_SCOPE_DOMAIN, mlir::LLVM::AliasScopeDomainAttr) \
-   _llvm(AliasScopeAttr, AttributeKind::LLVM_ALIAS_SCOPE, mlir::LLVM::AliasScopeAttr) \
-   _llvm(AccessGroupAttr, AttributeKind::LLVM_ACCESS_GROUP, mlir::LLVM::AccessGroupAttr) \
-   _llvm(TBAARootAttr, AttributeKind::LLVM_TBAA_ROOT, mlir::LLVM::TBAARootAttr) \
-   _llvm(TBAAMemberAttr, AttributeKind::LLVM_TBAA_MEMBER, mlir::LLVM::TBAAMemberAttr) \
-   _llvm(TBAATypeDescriptorAttr, AttributeKind::LLVM_TBAA_TYPE_DESCRIPTOR, mlir::LLVM::TBAATypeDescriptorAttr) \
-   _llvm(TBAATagAttr, AttributeKind::LLVM_TBAA_TAG, mlir::LLVM::TBAATagAttr) \
-   _llvm(VScaleRangeAttr, AttributeKind::LLVM_V_SCALE_RANGE, mlir::LLVM::VScaleRangeAttr) \
-   _llvm(TargetFeaturesAttr, AttributeKind::LLVM_TARGET_FEATURES, mlir::LLVM::TargetFeaturesAttr) \
-   _llvm(IntegerOverflowFlagsAttr, AttributeKind::LLVM_INTEGER_OVERFLOW_FLAGS, mlir::LLVM::IntegerOverflowFlagsAttr) \
-   _llvm(FastmathFlagsAttr, AttributeKind::LLVM_FASTMATH_FLAGS, mlir::LLVM::FastmathFlagsAttr) \
-   _hl(AnnotationAttr, AttributeKind::HL_ANNOTATION, vast::hl::AnnotationAttr) \
-   _hl(FormatAttr, AttributeKind::HL_FORMAT, vast::hl::FormatAttr) \
-   _hl(SectionAttr, AttributeKind::HL_SECTION, vast::hl::SectionAttr) \
-   _hl(AliasAttr, AttributeKind::HL_ALIAS, vast::hl::AliasAttr) \
-   _hl(ErrorAttr, AttributeKind::HL_ERROR, vast::hl::ErrorAttr) \
-   _hl(CountedByAttr, AttributeKind::HL_COUNTED_BY, vast::hl::CountedByAttr) \
-   _hl(CleanupAttr, AttributeKind::HL_CLEANUP, vast::hl::CleanupAttr) \
-   _hl(AlignedAttr, AttributeKind::HL_ALIGNED, vast::hl::AlignedAttr) \
-   _hl(AlwaysInlineAttr, AttributeKind::HL_ALWAYS_INLINE, vast::hl::AlwaysInlineAttr) \
-   _hl(NoInlineAttr, AttributeKind::HL_NO_INLINE, vast::hl::NoInlineAttr) \
-   _hl(ConstAttr, AttributeKind::HL_CONST, vast::hl::ConstAttr) \
-   _hl(LoaderUninitializedAttr, AttributeKind::HL_LOADER_UNINITIALIZED, vast::hl::LoaderUninitializedAttr) \
-   _hl(NoInstrumentFunctionAttr, AttributeKind::HL_NO_INSTRUMENT_FUNCTION, vast::hl::NoInstrumentFunctionAttr) \
-   _hl(PackedAttr, AttributeKind::HL_PACKED, vast::hl::PackedAttr) \
-   _hl(PureAttr, AttributeKind::HL_PURE, vast::hl::PureAttr) \
-   _hl(WarnUnusedResultAttr, AttributeKind::HL_WARN_UNUSED_RESULT, vast::hl::WarnUnusedResultAttr) \
-   _hl(RestrictAttr, AttributeKind::HL_RESTRICT, vast::hl::RestrictAttr) \
-   _hl(NoThrowAttr, AttributeKind::HL_NO_THROW, vast::hl::NoThrowAttr) \
-   _hl(NonNullAttr, AttributeKind::HL_NON_NULL, vast::hl::NonNullAttr) \
-   _hl(LeafAttr, AttributeKind::HL_LEAF, vast::hl::LeafAttr) \
-   _hl(ColdAttr, AttributeKind::HL_COLD, vast::hl::ColdAttr) \
-   _hl(TransparentUnionAttr, AttributeKind::HL_TRANSPARENT_UNION, vast::hl::TransparentUnionAttr) \
-   _hl(ReturnsTwiceAttr, AttributeKind::HL_RETURNS_TWICE, vast::hl::ReturnsTwiceAttr) \
-   _hl(MayAliasAttr, AttributeKind::HL_MAY_ALIAS, vast::hl::MayAliasAttr) \
-   _hl(UnusedAttr, AttributeKind::HL_UNUSED, vast::hl::UnusedAttr) \
-   _hl(UsedAttr, AttributeKind::HL_USED, vast::hl::UsedAttr) \
-   _hl(GNUInlineAttr, AttributeKind::HL_GNU_INLINE, vast::hl::GNUInlineAttr) \
-   _hl(NoCfCheckAttr, AttributeKind::HL_NO_CF_CHECK, vast::hl::NoCfCheckAttr) \
-   _hl(AvailableOnlyInDefaultEvalMethodAttr, AttributeKind::HL_AVAILABLE_ONLY_IN_DEFAULT_EVAL_METHOD, vast::hl::AvailableOnlyInDefaultEvalMethodAttr) \
-   _hl(AvailabilityAttrAttr, AttributeKind::HL_AVAILABILITY_ATTR, vast::hl::AvailabilityAttrAttr) \
-   _hl(FallthroughAttr, AttributeKind::HL_FALLTHROUGH, vast::hl::FallthroughAttr) \
-   _hl(NoProfileInstrumentFunctionAttr, AttributeKind::HL_NO_PROFILE_INSTRUMENT_FUNCTION, vast::hl::NoProfileInstrumentFunctionAttr) \
-   _hl(AsmLabelAttr, AttributeKind::HL_ASM_LABEL, vast::hl::AsmLabelAttr) \
-   _hl(ModeAttr, AttributeKind::HL_MODE, vast::hl::ModeAttr) \
-   _hl(BuiltinAttr, AttributeKind::HL_BUILTIN, vast::hl::BuiltinAttr) \
-   _hl(AllocAlignAttr, AttributeKind::HL_ALLOC_ALIGN, vast::hl::AllocAlignAttr) \
-   _hl(AllocSizeAttr, AttributeKind::HL_ALLOC_SIZE, vast::hl::AllocSizeAttr) \
-   _hl(DeprecatedAttr, AttributeKind::HL_DEPRECATED, vast::hl::DeprecatedAttr) \
-   _hl(MaxFieldAlignmentAttr, AttributeKind::HL_MAX_FIELD_ALIGNMENT, vast::hl::MaxFieldAlignmentAttr) \
-   _hl(VisibilityAttr, AttributeKind::HL_VISIBILITY, vast::hl::VisibilityAttr) \
-   _hl(AssumeAlignedAttr, AttributeKind::HL_ASSUME_ALIGNED, vast::hl::AssumeAlignedAttr) \
-   _hl(CVQualifiersAttr, AttributeKind::HL_CV_QUALIFIERS, vast::hl::CVQualifiersAttr) \
-   _hl(UCVQualifiersAttr, AttributeKind::HL_UCV_QUALIFIERS, vast::hl::UCVQualifiersAttr) \
-   _hl(CVRQualifiersAttr, AttributeKind::HL_CVR_QUALIFIERS, vast::hl::CVRQualifiersAttr) \
-   _hl(OffsetOfNodeAttr, AttributeKind::HL_OFFSET_OF_NODE, vast::hl::OffsetOfNodeAttr) \
-   _core(BooleanAttr, AttributeKind::CORE_BOOLEAN, vast::core::BooleanAttr) \
-   _core(IntegerAttr, AttributeKind::CORE_INTEGER, vast::core::IntegerAttr) \
-   _core(FloatAttr, AttributeKind::CORE_FLOAT, vast::core::FloatAttr) \
-   _core(VoidAttr, AttributeKind::CORE_VOID, vast::core::VoidAttr) \
-   _core(SourceLanguageAttr, AttributeKind::CORE_SOURCE_LANGUAGE, vast::core::SourceLanguageAttr) \
-   _core(GlobalLinkageKindAttr, AttributeKind::CORE_GLOBAL_LINKAGE_KIND, vast::core::GlobalLinkageKindAttr) \
-   _meta(IdentifierAttr, AttributeKind::META_IDENTIFIER, vast::meta::IdentifierAttr)
-
-#define MX_IR_NUM_MLIR_ATTRIBUTES 120
-
diff --git a/lib/IR/AttributeKind.cpp b/lib/IR/AttributeKind.cpp
deleted file mode 100644
index 0e1b60a41..000000000
--- a/lib/IR/AttributeKind.cpp
+++ /dev/null
@@ -1,326 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/AttributeKind.h>
-
-namespace mx {
-
-const char *EnumeratorName(ir::AttributeKind kind) {
-  switch (kind) {
-    default: return "UNKNOWN";
-    case ir::AttributeKind::BUILTIN_TYPED: return "BUILTIN_TYPED";
-    case ir::AttributeKind::BUILTIN_ELEMENTS: return "BUILTIN_ELEMENTS";
-    case ir::AttributeKind::BUILTIN_AFFINE_MAP: return "BUILTIN_AFFINE_MAP";
-    case ir::AttributeKind::BUILTIN_ARRAY: return "BUILTIN_ARRAY";
-    case ir::AttributeKind::BUILTIN_DENSE_ARRAY: return "BUILTIN_DENSE_ARRAY";
-    case ir::AttributeKind::BUILTIN_DENSE_INT_OR_FP_ELEMENTS: return "BUILTIN_DENSE_INT_OR_FP_ELEMENTS";
-    case ir::AttributeKind::BUILTIN_DENSE_STRING_ELEMENTS: return "BUILTIN_DENSE_STRING_ELEMENTS";
-    case ir::AttributeKind::BUILTIN_DENSE_RESOURCE_ELEMENTS: return "BUILTIN_DENSE_RESOURCE_ELEMENTS";
-    case ir::AttributeKind::BUILTIN_DICTIONARY: return "BUILTIN_DICTIONARY";
-    case ir::AttributeKind::BUILTIN_FLOAT: return "BUILTIN_FLOAT";
-    case ir::AttributeKind::BUILTIN_INTEGER: return "BUILTIN_INTEGER";
-    case ir::AttributeKind::BUILTIN_INTEGER_SET: return "BUILTIN_INTEGER_SET";
-    case ir::AttributeKind::BUILTIN_OPAQUE: return "BUILTIN_OPAQUE";
-    case ir::AttributeKind::BUILTIN_SPARSE_ELEMENTS: return "BUILTIN_SPARSE_ELEMENTS";
-    case ir::AttributeKind::BUILTIN_STRIDED_LAYOUT: return "BUILTIN_STRIDED_LAYOUT";
-    case ir::AttributeKind::BUILTIN_STRING: return "BUILTIN_STRING";
-    case ir::AttributeKind::BUILTIN_SYMBOL_REF: return "BUILTIN_SYMBOL_REF";
-    case ir::AttributeKind::BUILTIN_TYPE: return "BUILTIN_TYPE";
-    case ir::AttributeKind::BUILTIN_UNIT: return "BUILTIN_UNIT";
-    case ir::AttributeKind::BUILTIN_BOOL: return "BUILTIN_BOOL";
-    case ir::AttributeKind::BUILTIN_FLAT_SYMBOL_REF: return "BUILTIN_FLAT_SYMBOL_REF";
-    case ir::AttributeKind::BUILTIN_DENSE_INT_ELEMENTS: return "BUILTIN_DENSE_INT_ELEMENTS";
-    case ir::AttributeKind::BUILTIN_DATA_LAYOUT_SPEC: return "BUILTIN_DATA_LAYOUT_SPEC";
-    case ir::AttributeKind::LLVM_C_CONV: return "LLVM_C_CONV";
-    case ir::AttributeKind::LLVM_COMDAT: return "LLVM_COMDAT";
-    case ir::AttributeKind::LLVM_LINKAGE: return "LLVM_LINKAGE";
-    case ir::AttributeKind::LLVM_FRAME_POINTER_KIND: return "LLVM_FRAME_POINTER_KIND";
-    case ir::AttributeKind::LLVM_LOOP_VECTORIZE: return "LLVM_LOOP_VECTORIZE";
-    case ir::AttributeKind::LLVM_LOOP_INTERLEAVE: return "LLVM_LOOP_INTERLEAVE";
-    case ir::AttributeKind::LLVM_LOOP_UNROLL: return "LLVM_LOOP_UNROLL";
-    case ir::AttributeKind::LLVM_LOOP_UNROLL_AND_JAM: return "LLVM_LOOP_UNROLL_AND_JAM";
-    case ir::AttributeKind::LLVM_LOOP_LICM: return "LLVM_LOOP_LICM";
-    case ir::AttributeKind::LLVM_LOOP_DISTRIBUTE: return "LLVM_LOOP_DISTRIBUTE";
-    case ir::AttributeKind::LLVM_LOOP_PIPELINE: return "LLVM_LOOP_PIPELINE";
-    case ir::AttributeKind::LLVM_LOOP_PEELED: return "LLVM_LOOP_PEELED";
-    case ir::AttributeKind::LLVM_LOOP_UNSWITCH: return "LLVM_LOOP_UNSWITCH";
-    case ir::AttributeKind::LLVM_LOOP_ANNOTATION: return "LLVM_LOOP_ANNOTATION";
-    case ir::AttributeKind::LLVM_DI_EXPRESSION_ELEM: return "LLVM_DI_EXPRESSION_ELEM";
-    case ir::AttributeKind::LLVM_DI_EXPRESSION: return "LLVM_DI_EXPRESSION";
-    case ir::AttributeKind::LLVM_DI_NULL_TYPE: return "LLVM_DI_NULL_TYPE";
-    case ir::AttributeKind::LLVM_DI_BASIC_TYPE: return "LLVM_DI_BASIC_TYPE";
-    case ir::AttributeKind::LLVM_DI_COMPILE_UNIT: return "LLVM_DI_COMPILE_UNIT";
-    case ir::AttributeKind::LLVM_DI_COMPOSITE_TYPE: return "LLVM_DI_COMPOSITE_TYPE";
-    case ir::AttributeKind::LLVM_DI_DERIVED_TYPE: return "LLVM_DI_DERIVED_TYPE";
-    case ir::AttributeKind::LLVM_DI_FILE: return "LLVM_DI_FILE";
-    case ir::AttributeKind::LLVM_DI_GLOBAL_VARIABLE_EXPRESSION: return "LLVM_DI_GLOBAL_VARIABLE_EXPRESSION";
-    case ir::AttributeKind::LLVM_DI_GLOBAL_VARIABLE: return "LLVM_DI_GLOBAL_VARIABLE";
-    case ir::AttributeKind::LLVM_DI_LEXICAL_BLOCK: return "LLVM_DI_LEXICAL_BLOCK";
-    case ir::AttributeKind::LLVM_DI_LEXICAL_BLOCK_FILE: return "LLVM_DI_LEXICAL_BLOCK_FILE";
-    case ir::AttributeKind::LLVM_DI_LOCAL_VARIABLE: return "LLVM_DI_LOCAL_VARIABLE";
-    case ir::AttributeKind::LLVM_DI_SUBPROGRAM: return "LLVM_DI_SUBPROGRAM";
-    case ir::AttributeKind::LLVM_DI_MODULE: return "LLVM_DI_MODULE";
-    case ir::AttributeKind::LLVM_DI_NAMESPACE: return "LLVM_DI_NAMESPACE";
-    case ir::AttributeKind::LLVM_DI_SUBRANGE: return "LLVM_DI_SUBRANGE";
-    case ir::AttributeKind::LLVM_DI_SUBROUTINE_TYPE: return "LLVM_DI_SUBROUTINE_TYPE";
-    case ir::AttributeKind::LLVM_DI_LABEL: return "LLVM_DI_LABEL";
-    case ir::AttributeKind::LLVM_MEMORY_EFFECTS: return "LLVM_MEMORY_EFFECTS";
-    case ir::AttributeKind::LLVM_ALIAS_SCOPE_DOMAIN: return "LLVM_ALIAS_SCOPE_DOMAIN";
-    case ir::AttributeKind::LLVM_ALIAS_SCOPE: return "LLVM_ALIAS_SCOPE";
-    case ir::AttributeKind::LLVM_ACCESS_GROUP: return "LLVM_ACCESS_GROUP";
-    case ir::AttributeKind::LLVM_TBAA_ROOT: return "LLVM_TBAA_ROOT";
-    case ir::AttributeKind::LLVM_TBAA_MEMBER: return "LLVM_TBAA_MEMBER";
-    case ir::AttributeKind::LLVM_TBAA_TYPE_DESCRIPTOR: return "LLVM_TBAA_TYPE_DESCRIPTOR";
-    case ir::AttributeKind::LLVM_TBAA_TAG: return "LLVM_TBAA_TAG";
-    case ir::AttributeKind::LLVM_V_SCALE_RANGE: return "LLVM_V_SCALE_RANGE";
-    case ir::AttributeKind::LLVM_TARGET_FEATURES: return "LLVM_TARGET_FEATURES";
-    case ir::AttributeKind::LLVM_INTEGER_OVERFLOW_FLAGS: return "LLVM_INTEGER_OVERFLOW_FLAGS";
-    case ir::AttributeKind::LLVM_FASTMATH_FLAGS: return "LLVM_FASTMATH_FLAGS";
-    case ir::AttributeKind::HL_ANNOTATION: return "HL_ANNOTATION";
-    case ir::AttributeKind::HL_FORMAT: return "HL_FORMAT";
-    case ir::AttributeKind::HL_SECTION: return "HL_SECTION";
-    case ir::AttributeKind::HL_ALIAS: return "HL_ALIAS";
-    case ir::AttributeKind::HL_ERROR: return "HL_ERROR";
-    case ir::AttributeKind::HL_COUNTED_BY: return "HL_COUNTED_BY";
-    case ir::AttributeKind::HL_CLEANUP: return "HL_CLEANUP";
-    case ir::AttributeKind::HL_ALIGNED: return "HL_ALIGNED";
-    case ir::AttributeKind::HL_ALWAYS_INLINE: return "HL_ALWAYS_INLINE";
-    case ir::AttributeKind::HL_NO_INLINE: return "HL_NO_INLINE";
-    case ir::AttributeKind::HL_CONST: return "HL_CONST";
-    case ir::AttributeKind::HL_LOADER_UNINITIALIZED: return "HL_LOADER_UNINITIALIZED";
-    case ir::AttributeKind::HL_NO_INSTRUMENT_FUNCTION: return "HL_NO_INSTRUMENT_FUNCTION";
-    case ir::AttributeKind::HL_PACKED: return "HL_PACKED";
-    case ir::AttributeKind::HL_PURE: return "HL_PURE";
-    case ir::AttributeKind::HL_WARN_UNUSED_RESULT: return "HL_WARN_UNUSED_RESULT";
-    case ir::AttributeKind::HL_RESTRICT: return "HL_RESTRICT";
-    case ir::AttributeKind::HL_NO_THROW: return "HL_NO_THROW";
-    case ir::AttributeKind::HL_NON_NULL: return "HL_NON_NULL";
-    case ir::AttributeKind::HL_LEAF: return "HL_LEAF";
-    case ir::AttributeKind::HL_COLD: return "HL_COLD";
-    case ir::AttributeKind::HL_TRANSPARENT_UNION: return "HL_TRANSPARENT_UNION";
-    case ir::AttributeKind::HL_RETURNS_TWICE: return "HL_RETURNS_TWICE";
-    case ir::AttributeKind::HL_MAY_ALIAS: return "HL_MAY_ALIAS";
-    case ir::AttributeKind::HL_UNUSED: return "HL_UNUSED";
-    case ir::AttributeKind::HL_USED: return "HL_USED";
-    case ir::AttributeKind::HL_GNU_INLINE: return "HL_GNU_INLINE";
-    case ir::AttributeKind::HL_NO_CF_CHECK: return "HL_NO_CF_CHECK";
-    case ir::AttributeKind::HL_AVAILABLE_ONLY_IN_DEFAULT_EVAL_METHOD: return "HL_AVAILABLE_ONLY_IN_DEFAULT_EVAL_METHOD";
-    case ir::AttributeKind::HL_AVAILABILITY_ATTR: return "HL_AVAILABILITY_ATTR";
-    case ir::AttributeKind::HL_FALLTHROUGH: return "HL_FALLTHROUGH";
-    case ir::AttributeKind::HL_NO_PROFILE_INSTRUMENT_FUNCTION: return "HL_NO_PROFILE_INSTRUMENT_FUNCTION";
-    case ir::AttributeKind::HL_ASM_LABEL: return "HL_ASM_LABEL";
-    case ir::AttributeKind::HL_MODE: return "HL_MODE";
-    case ir::AttributeKind::HL_BUILTIN: return "HL_BUILTIN";
-    case ir::AttributeKind::HL_ALLOC_ALIGN: return "HL_ALLOC_ALIGN";
-    case ir::AttributeKind::HL_ALLOC_SIZE: return "HL_ALLOC_SIZE";
-    case ir::AttributeKind::HL_DEPRECATED: return "HL_DEPRECATED";
-    case ir::AttributeKind::HL_MAX_FIELD_ALIGNMENT: return "HL_MAX_FIELD_ALIGNMENT";
-    case ir::AttributeKind::HL_VISIBILITY: return "HL_VISIBILITY";
-    case ir::AttributeKind::HL_ASSUME_ALIGNED: return "HL_ASSUME_ALIGNED";
-    case ir::AttributeKind::HL_CV_QUALIFIERS: return "HL_CV_QUALIFIERS";
-    case ir::AttributeKind::HL_UCV_QUALIFIERS: return "HL_UCV_QUALIFIERS";
-    case ir::AttributeKind::HL_CVR_QUALIFIERS: return "HL_CVR_QUALIFIERS";
-    case ir::AttributeKind::HL_OFFSET_OF_NODE: return "HL_OFFSET_OF_NODE";
-    case ir::AttributeKind::CORE_BOOLEAN: return "CORE_BOOLEAN";
-    case ir::AttributeKind::CORE_INTEGER: return "CORE_INTEGER";
-    case ir::AttributeKind::CORE_FLOAT: return "CORE_FLOAT";
-    case ir::AttributeKind::CORE_VOID: return "CORE_VOID";
-    case ir::AttributeKind::CORE_SOURCE_LANGUAGE: return "CORE_SOURCE_LANGUAGE";
-    case ir::AttributeKind::CORE_GLOBAL_LINKAGE_KIND: return "CORE_GLOBAL_LINKAGE_KIND";
-    case ir::AttributeKind::META_IDENTIFIER: return "META_IDENTIFIER";
-  }
-}
-
-bool IsBuiltinAttributeKind(ir::AttributeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::AttributeKind::BUILTIN_TYPED:
-    case mx::ir::AttributeKind::BUILTIN_ELEMENTS:
-    case mx::ir::AttributeKind::BUILTIN_AFFINE_MAP:
-    case mx::ir::AttributeKind::BUILTIN_ARRAY:
-    case mx::ir::AttributeKind::BUILTIN_DENSE_ARRAY:
-    case mx::ir::AttributeKind::BUILTIN_DENSE_INT_OR_FP_ELEMENTS:
-    case mx::ir::AttributeKind::BUILTIN_DENSE_STRING_ELEMENTS:
-    case mx::ir::AttributeKind::BUILTIN_DENSE_RESOURCE_ELEMENTS:
-    case mx::ir::AttributeKind::BUILTIN_DICTIONARY:
-    case mx::ir::AttributeKind::BUILTIN_FLOAT:
-    case mx::ir::AttributeKind::BUILTIN_INTEGER:
-    case mx::ir::AttributeKind::BUILTIN_INTEGER_SET:
-    case mx::ir::AttributeKind::BUILTIN_OPAQUE:
-    case mx::ir::AttributeKind::BUILTIN_SPARSE_ELEMENTS:
-    case mx::ir::AttributeKind::BUILTIN_STRIDED_LAYOUT:
-    case mx::ir::AttributeKind::BUILTIN_STRING:
-    case mx::ir::AttributeKind::BUILTIN_SYMBOL_REF:
-    case mx::ir::AttributeKind::BUILTIN_TYPE:
-    case mx::ir::AttributeKind::BUILTIN_UNIT:
-    case mx::ir::AttributeKind::BUILTIN_BOOL:
-    case mx::ir::AttributeKind::BUILTIN_FLAT_SYMBOL_REF:
-    case mx::ir::AttributeKind::BUILTIN_DENSE_INT_ELEMENTS:
-    case mx::ir::AttributeKind::BUILTIN_DATA_LAYOUT_SPEC:
-      return true;
-  }
-}
-
-bool IsLLVMIRAttributeKind(ir::AttributeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::AttributeKind::LLVM_C_CONV:
-    case mx::ir::AttributeKind::LLVM_COMDAT:
-    case mx::ir::AttributeKind::LLVM_LINKAGE:
-    case mx::ir::AttributeKind::LLVM_FRAME_POINTER_KIND:
-    case mx::ir::AttributeKind::LLVM_LOOP_VECTORIZE:
-    case mx::ir::AttributeKind::LLVM_LOOP_INTERLEAVE:
-    case mx::ir::AttributeKind::LLVM_LOOP_UNROLL:
-    case mx::ir::AttributeKind::LLVM_LOOP_UNROLL_AND_JAM:
-    case mx::ir::AttributeKind::LLVM_LOOP_LICM:
-    case mx::ir::AttributeKind::LLVM_LOOP_DISTRIBUTE:
-    case mx::ir::AttributeKind::LLVM_LOOP_PIPELINE:
-    case mx::ir::AttributeKind::LLVM_LOOP_PEELED:
-    case mx::ir::AttributeKind::LLVM_LOOP_UNSWITCH:
-    case mx::ir::AttributeKind::LLVM_LOOP_ANNOTATION:
-    case mx::ir::AttributeKind::LLVM_DI_EXPRESSION_ELEM:
-    case mx::ir::AttributeKind::LLVM_DI_EXPRESSION:
-    case mx::ir::AttributeKind::LLVM_DI_NULL_TYPE:
-    case mx::ir::AttributeKind::LLVM_DI_BASIC_TYPE:
-    case mx::ir::AttributeKind::LLVM_DI_COMPILE_UNIT:
-    case mx::ir::AttributeKind::LLVM_DI_COMPOSITE_TYPE:
-    case mx::ir::AttributeKind::LLVM_DI_DERIVED_TYPE:
-    case mx::ir::AttributeKind::LLVM_DI_FILE:
-    case mx::ir::AttributeKind::LLVM_DI_GLOBAL_VARIABLE_EXPRESSION:
-    case mx::ir::AttributeKind::LLVM_DI_GLOBAL_VARIABLE:
-    case mx::ir::AttributeKind::LLVM_DI_LEXICAL_BLOCK:
-    case mx::ir::AttributeKind::LLVM_DI_LEXICAL_BLOCK_FILE:
-    case mx::ir::AttributeKind::LLVM_DI_LOCAL_VARIABLE:
-    case mx::ir::AttributeKind::LLVM_DI_SUBPROGRAM:
-    case mx::ir::AttributeKind::LLVM_DI_MODULE:
-    case mx::ir::AttributeKind::LLVM_DI_NAMESPACE:
-    case mx::ir::AttributeKind::LLVM_DI_SUBRANGE:
-    case mx::ir::AttributeKind::LLVM_DI_SUBROUTINE_TYPE:
-    case mx::ir::AttributeKind::LLVM_DI_LABEL:
-    case mx::ir::AttributeKind::LLVM_MEMORY_EFFECTS:
-    case mx::ir::AttributeKind::LLVM_ALIAS_SCOPE_DOMAIN:
-    case mx::ir::AttributeKind::LLVM_ALIAS_SCOPE:
-    case mx::ir::AttributeKind::LLVM_ACCESS_GROUP:
-    case mx::ir::AttributeKind::LLVM_TBAA_ROOT:
-    case mx::ir::AttributeKind::LLVM_TBAA_MEMBER:
-    case mx::ir::AttributeKind::LLVM_TBAA_TYPE_DESCRIPTOR:
-    case mx::ir::AttributeKind::LLVM_TBAA_TAG:
-    case mx::ir::AttributeKind::LLVM_V_SCALE_RANGE:
-    case mx::ir::AttributeKind::LLVM_TARGET_FEATURES:
-    case mx::ir::AttributeKind::LLVM_INTEGER_OVERFLOW_FLAGS:
-    case mx::ir::AttributeKind::LLVM_FASTMATH_FLAGS:
-      return true;
-  }
-}
-
-bool IsMemRefAttributeKind(ir::AttributeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-  }
-}
-
-bool IsABIAttributeKind(ir::AttributeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-  }
-}
-
-bool IsLowLevelAttributeKind(ir::AttributeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-  }
-}
-
-bool IsHighLevelAttributeKind(ir::AttributeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::AttributeKind::HL_ANNOTATION:
-    case mx::ir::AttributeKind::HL_FORMAT:
-    case mx::ir::AttributeKind::HL_SECTION:
-    case mx::ir::AttributeKind::HL_ALIAS:
-    case mx::ir::AttributeKind::HL_ERROR:
-    case mx::ir::AttributeKind::HL_COUNTED_BY:
-    case mx::ir::AttributeKind::HL_CLEANUP:
-    case mx::ir::AttributeKind::HL_ALIGNED:
-    case mx::ir::AttributeKind::HL_ALWAYS_INLINE:
-    case mx::ir::AttributeKind::HL_NO_INLINE:
-    case mx::ir::AttributeKind::HL_CONST:
-    case mx::ir::AttributeKind::HL_LOADER_UNINITIALIZED:
-    case mx::ir::AttributeKind::HL_NO_INSTRUMENT_FUNCTION:
-    case mx::ir::AttributeKind::HL_PACKED:
-    case mx::ir::AttributeKind::HL_PURE:
-    case mx::ir::AttributeKind::HL_WARN_UNUSED_RESULT:
-    case mx::ir::AttributeKind::HL_RESTRICT:
-    case mx::ir::AttributeKind::HL_NO_THROW:
-    case mx::ir::AttributeKind::HL_NON_NULL:
-    case mx::ir::AttributeKind::HL_LEAF:
-    case mx::ir::AttributeKind::HL_COLD:
-    case mx::ir::AttributeKind::HL_TRANSPARENT_UNION:
-    case mx::ir::AttributeKind::HL_RETURNS_TWICE:
-    case mx::ir::AttributeKind::HL_MAY_ALIAS:
-    case mx::ir::AttributeKind::HL_UNUSED:
-    case mx::ir::AttributeKind::HL_USED:
-    case mx::ir::AttributeKind::HL_GNU_INLINE:
-    case mx::ir::AttributeKind::HL_NO_CF_CHECK:
-    case mx::ir::AttributeKind::HL_AVAILABLE_ONLY_IN_DEFAULT_EVAL_METHOD:
-    case mx::ir::AttributeKind::HL_AVAILABILITY_ATTR:
-    case mx::ir::AttributeKind::HL_FALLTHROUGH:
-    case mx::ir::AttributeKind::HL_NO_PROFILE_INSTRUMENT_FUNCTION:
-    case mx::ir::AttributeKind::HL_ASM_LABEL:
-    case mx::ir::AttributeKind::HL_MODE:
-    case mx::ir::AttributeKind::HL_BUILTIN:
-    case mx::ir::AttributeKind::HL_ALLOC_ALIGN:
-    case mx::ir::AttributeKind::HL_ALLOC_SIZE:
-    case mx::ir::AttributeKind::HL_DEPRECATED:
-    case mx::ir::AttributeKind::HL_MAX_FIELD_ALIGNMENT:
-    case mx::ir::AttributeKind::HL_VISIBILITY:
-    case mx::ir::AttributeKind::HL_ASSUME_ALIGNED:
-    case mx::ir::AttributeKind::HL_CV_QUALIFIERS:
-    case mx::ir::AttributeKind::HL_UCV_QUALIFIERS:
-    case mx::ir::AttributeKind::HL_CVR_QUALIFIERS:
-    case mx::ir::AttributeKind::HL_OFFSET_OF_NODE:
-      return true;
-  }
-}
-
-bool IsCoreAttributeKind(ir::AttributeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::AttributeKind::CORE_BOOLEAN:
-    case mx::ir::AttributeKind::CORE_INTEGER:
-    case mx::ir::AttributeKind::CORE_FLOAT:
-    case mx::ir::AttributeKind::CORE_VOID:
-    case mx::ir::AttributeKind::CORE_SOURCE_LANGUAGE:
-    case mx::ir::AttributeKind::CORE_GLOBAL_LINKAGE_KIND:
-      return true;
-  }
-}
-
-bool IsMetaAttributeKind(ir::AttributeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::AttributeKind::META_IDENTIFIER:
-      return true;
-  }
-}
-
-bool IsUnsupportedAttributeKind(ir::AttributeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-  }
-}
-
-}  // namespace mx
diff --git a/lib/IR/Block.cpp b/lib/IR/Block.cpp
deleted file mode 100644
index f22cf0690..000000000
--- a/lib/IR/Block.cpp
+++ /dev/null
@@ -1,231 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#include <multiplier/IR/Block.h>
-
-#include <cassert>
-
-#include <mlir/IR/Block.h>
-#include <mlir/IR/Operation.h>
-#include <mlir/IR/OperationSupport.h>
-#include <mlir/IR/Region.h>
-#include <mlir/IR/Value.h>
-#include <multiplier/IR/Operation.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Value.h>
-
-#include "SourceIR.h"
-
-namespace mx::ir {
-
-bool BlocksMatch(
-    const std::shared_ptr<const SourceIRImpl> &a_mod, mlir::Block *a,
-    const std::shared_ptr<const SourceIRImpl> &b_mod, mlir::Block *b) {
-  if (a == b) {
-    return true;
-  }
-
-  if (a_mod == b_mod) {
-    return false;
-  }
-
-  auto a_op = a->getParentOp();
-  auto b_op = b->getParentOp();
-
-  // Same pointers for the parent op means that these blocks must have the
-  // same address to be equivalent.
-  if (a_op == b_op) {
-    return false;
-  }
-
-  if (!OperationIdsMatch(a_op, b_op)) {
-    return false;
-  }
-
-  if (a->getNumArguments() != b->getNumArguments()) {
-    return false;
-  }
-
-  if (a->empty() != b->empty()) {
-    return false;
-  }
-
-  auto a_region = a->getParent();
-  auto b_region = b->getParent();
-
-  assert(a_region != b_region);
-
-  // If these two blocks are nested inside of equivalent operations, then we
-  // need to figure out if the regions containing these blocks are logically
-  // equivalent.
-  if (a_region->getRegionNumber() !=
-      b_region->getRegionNumber()) {
-    return false;
-  }
-
-#ifndef NDEBUG
-  // If the blocks aren't empty, and the blocks are nested inside of equivalent
-  // operations, then we expect the first two operations in the non-empty blocks
-  // to also be equal.
-  if (!a->empty()) {
-    assert(a->getNumSuccessors() == b->getNumSuccessors());
-
-    mlir::Operation &first = a->getOperations().front();
-    mlir::Operation &that_first = b->getOperations().front();
-    assert(OperationIdsMatch(&first, &that_first));
-  }
-#endif
-
-  return true;
-}
-
-Block::Block(std::shared_ptr<const SourceIRImpl> module,
-             mlir::Block *block)
-    : module_(std::move(module)),
-      block_(block) {
-  assert(block_ != nullptr);
-}
-
-// Return the block containing a given argument.
-Block Block::containing(const Argument &arg_) {
-  mlir::BlockArgument arg(arg_.impl_.arg);
-  return Block(arg_.module_, arg.getParentBlock());
-}
-
-// We almost always have an owning block for an operation. The exception is
-// the `mx::ir::builtin::ModuleOp` case.
-std::optional<Block> Block::containing(const Operation &op) {
-  if (mlir::Block *block = op.op_->getBlock()) {
-    return Block(op.module_, block);
-  } else {
-    return std::nullopt;
-  }
-}
-
-unsigned Block::num_arguments(void) const noexcept {
-  return block_->getNumArguments();
-}
-
-std::optional<Argument> Block::nth_argument(unsigned i) const noexcept {
-  if (i < block_->getNumArguments()) {
-    return Argument(
-        module_,
-        reinterpret_cast<mlir::detail::BlockArgumentImpl *>(
-            block_->getArguments()[i].getAsOpaquePointer()));
-  }
-  return std::nullopt;
-}
-
-// Arguments to the block. Block arguments are like PHI nodes.
-gap::generator<Argument> Block::arguments(void) const & noexcept {
-  for (mlir::BlockArgument arg : block_->getArguments()) {
-    co_yield Argument(module_,
-                      reinterpret_cast<mlir::detail::BlockArgumentImpl *>(
-                          arg.getAsOpaquePointer()));
-  }
-}
-
-// Operations within a block. Every block has at least one operation, its
-// terminator.
-gap::generator<Operation> Block::operations(void) const & noexcept {
-  for (mlir::Operation &op : block_->getOperations()) {
-    co_yield Operation(module_, &op);
-  }
-}
-
-// Operations within a block in reverse order.
-gap::generator<Operation> Block::reverse_operations(void) const & noexcept {
-  mlir::Block::OpListType &ops = block_->getOperations();
-  for (auto it = ops.rbegin(), end = ops.rend(); it != end; ++it) {
-    co_yield Operation(module_, &*it);
-  }
-}
-
-// Set of operands that use this block. For example, a block can be an
-// operand to a terminator operation.
-gap::generator<Label> Block::uses(void) const & noexcept {
-  for (mlir::BlockOperand &op : block_->getUses()) {
-    co_yield Label(module_, &op);
-  }
-}
-
-// Return the terminating operation of a block.
-Operation Block::terminator(void) const noexcept {
-  return Operation(module_, block_->getTerminator());
-}
-
-bool Block::operator==(const Block &that) const noexcept {
-  return BlocksMatch(module_, block_, that.module_, that.block_);
-}
-
-std::optional<Argument> Argument::from(const Value &val) {
-  if (mlir::Value(val.impl_.value).isa<mlir::BlockArgument>()) {
-    return Argument(val.module_, val.impl_.arg);
-  }
-  return std::nullopt;
-}
-
-// Index of this block argument.
-unsigned Argument::index(void) const noexcept {
-  return mlir::BlockArgument(impl_.arg).getArgNumber();
-}
-
-bool Argument::operator==(const Argument &that) const noexcept {
-  if (underlying_value() == that.underlying_value()) {
-    return true;
-  }
-
-  if (module_ == that.module_) {
-    return false;
-  }
-
-  if (index() != that.index()) {
-    return false;
-  }
-
-  mlir::BlockArgument arg(impl_.arg);
-  mlir::BlockArgument that_arg(that.impl_.arg);
-
-  return BlocksMatch(module_, arg.getParentBlock(),
-                     that.module_, that_arg.getParentBlock());
-}
-
-// The operation containing this label.
-Operation Label::operation(void) const noexcept {
-  return Operation(module_, op_->getOwner());
-}
-
-Block Label::block(void) const noexcept {
-  return Block(module_, op_->get());
-}
-
-// The index of this label within its owner operation's block operand list.
-unsigned Label::index(void) const noexcept {
-  return op_->getOperandNumber();
-}
-
-bool Label::operator==(const Label &that) const noexcept {
-  if (op_ == that.op_) {
-    return true;
-  }
-
-  if (module_ == that.module_) {
-    return false;
-  }
-
-  if (index() != that.index()) {
-    return false;
-  }
-
-  if (!OperationIdsMatch(op_->getOwner(), that.op_->getOwner())) {
-    return false;
-  }
-
-  assert(BlocksMatch(module_, op_->get(), that.module_, that.op_->get()));
-
-  return true;
-}
-
-}  // namespace mx::ir
diff --git a/lib/IR/Builtin/Attribute.cpp b/lib/IR/Builtin/Attribute.cpp
deleted file mode 100644
index cd7fc1338..000000000
--- a/lib/IR/Builtin/Attribute.cpp
+++ /dev/null
@@ -1,438 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Attribute.h>
-
-#include <multiplier/IR/Type.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <mlir/Dialect/MemRef/IR/MemRef.h>
-#include <vast/Dialect/HighLevel/HighLevelOps.hpp>
-
-namespace mx::ir::builtin {
-std::optional<Attribute> Attribute::from(const ::mx::ir::Attribute &that) {
-  if (IsBuiltinAttributeKind(that.kind())) {
-    return reinterpret_cast<const Attribute &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TypedAttr> TypedAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_TYPED) {
-    return reinterpret_cast<const TypedAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::TypedAttr TypedAttr::underlying_repr(void) const noexcept {
-  return ::mlir::TypedAttr(this->::mx::ir::Attribute::attr_);
-}
-
-::mx::ir::Type TypedAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<ElementsAttr> ElementsAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_ELEMENTS) {
-    return reinterpret_cast<const ElementsAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::ElementsAttr ElementsAttr::underlying_repr(void) const noexcept {
-  return ::mlir::ElementsAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool ElementsAttr::is_splat(void) const {
-  auto val = underlying_repr().isSplat();
-  return val;
-}
-
-int64_t ElementsAttr::num_elements(void) const {
-  auto val = underlying_repr().getNumElements();
-  return val;
-}
-
-int64_t ElementsAttr::size(void) const {
-  auto val = underlying_repr().size();
-  return val;
-}
-
-bool ElementsAttr::empty(void) const {
-  auto val = underlying_repr().empty();
-  return val;
-}
-
-::mx::ir::Type ElementsAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<AffineMapAttr> AffineMapAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_AFFINE_MAP) {
-    return reinterpret_cast<const AffineMapAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::AffineMapAttr AffineMapAttr::underlying_repr(void) const noexcept {
-  return ::mlir::AffineMapAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<ArrayAttr> ArrayAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_ARRAY) {
-    return reinterpret_cast<const ArrayAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::ArrayAttr ArrayAttr::underlying_repr(void) const noexcept {
-  return ::mlir::ArrayAttr(this->::mx::ir::Attribute::attr_);
-}
-
-size_t ArrayAttr::size(void) const {
-  auto val = underlying_repr().size();
-  return val;
-}
-
-bool ArrayAttr::empty(void) const {
-  auto val = underlying_repr().empty();
-  return val;
-}
-
-std::optional<DenseArrayAttr> DenseArrayAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_DENSE_ARRAY) {
-    return reinterpret_cast<const DenseArrayAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::DenseArrayAttr DenseArrayAttr::underlying_repr(void) const noexcept {
-  return ::mlir::DenseArrayAttr(this->::mx::ir::Attribute::attr_);
-}
-
-int64_t DenseArrayAttr::size(void) const {
-  auto val = underlying_repr().size();
-  return val;
-}
-
-bool DenseArrayAttr::empty(void) const {
-  auto val = underlying_repr().empty();
-  return val;
-}
-
-std::optional<DenseIntOrFPElementsAttr> DenseIntOrFPElementsAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_DENSE_INT_OR_FP_ELEMENTS) {
-    return reinterpret_cast<const DenseIntOrFPElementsAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::DenseIntOrFPElementsAttr DenseIntOrFPElementsAttr::underlying_repr(void) const noexcept {
-  return ::mlir::DenseIntOrFPElementsAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DenseStringElementsAttr> DenseStringElementsAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_DENSE_STRING_ELEMENTS) {
-    return reinterpret_cast<const DenseStringElementsAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::DenseStringElementsAttr DenseStringElementsAttr::underlying_repr(void) const noexcept {
-  return ::mlir::DenseStringElementsAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DenseResourceElementsAttr> DenseResourceElementsAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_DENSE_RESOURCE_ELEMENTS) {
-    return reinterpret_cast<const DenseResourceElementsAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::DenseResourceElementsAttr DenseResourceElementsAttr::underlying_repr(void) const noexcept {
-  return ::mlir::DenseResourceElementsAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DictionaryAttr> DictionaryAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_DICTIONARY) {
-    return reinterpret_cast<const DictionaryAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::DictionaryAttr DictionaryAttr::underlying_repr(void) const noexcept {
-  return ::mlir::DictionaryAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool DictionaryAttr::empty(void) const {
-  auto val = underlying_repr().empty();
-  return val;
-}
-
-size_t DictionaryAttr::size(void) const {
-  auto val = underlying_repr().size();
-  return val;
-}
-
-std::optional<FloatAttr> FloatAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_FLOAT) {
-    return reinterpret_cast<const FloatAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::FloatAttr FloatAttr::underlying_repr(void) const noexcept {
-  return ::mlir::FloatAttr(this->::mx::ir::Attribute::attr_);
-}
-
-double FloatAttr::value_as_double(void) const {
-  auto val = underlying_repr().getValueAsDouble();
-  return val;
-}
-
-::mx::ir::Type FloatAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<IntegerAttr> IntegerAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_INTEGER) {
-    return reinterpret_cast<const IntegerAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::IntegerAttr IntegerAttr::underlying_repr(void) const noexcept {
-  return ::mlir::IntegerAttr(this->::mx::ir::Attribute::attr_);
-}
-
-int64_t IntegerAttr::integer_value(void) const {
-  auto val = underlying_repr().getInt();
-  return val;
-}
-
-int64_t IntegerAttr::signed_integer_value(void) const {
-  auto val = underlying_repr().getSInt();
-  return val;
-}
-
-uint64_t IntegerAttr::unsigned_integer_value(void) const {
-  auto val = underlying_repr().getUInt();
-  return val;
-}
-
-::mx::ir::Type IntegerAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<IntegerSetAttr> IntegerSetAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_INTEGER_SET) {
-    return reinterpret_cast<const IntegerSetAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::IntegerSetAttr IntegerSetAttr::underlying_repr(void) const noexcept {
-  return ::mlir::IntegerSetAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<OpaqueAttr> OpaqueAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_OPAQUE) {
-    return reinterpret_cast<const OpaqueAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::OpaqueAttr OpaqueAttr::underlying_repr(void) const noexcept {
-  return ::mlir::OpaqueAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::string_view OpaqueAttr::attr_data(void) const {
-  auto val = underlying_repr().getAttrData();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type OpaqueAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<SparseElementsAttr> SparseElementsAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_SPARSE_ELEMENTS) {
-    return reinterpret_cast<const SparseElementsAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::SparseElementsAttr SparseElementsAttr::underlying_repr(void) const noexcept {
-  return ::mlir::SparseElementsAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<StridedLayoutAttr> StridedLayoutAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_STRIDED_LAYOUT) {
-    return reinterpret_cast<const StridedLayoutAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::StridedLayoutAttr StridedLayoutAttr::underlying_repr(void) const noexcept {
-  return ::mlir::StridedLayoutAttr(this->::mx::ir::Attribute::attr_);
-}
-
-int64_t StridedLayoutAttr::offset(void) const {
-  auto val = underlying_repr().getOffset();
-  return val;
-}
-
-std::optional<StringAttr> StringAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_STRING) {
-    return reinterpret_cast<const StringAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::StringAttr StringAttr::underlying_repr(void) const noexcept {
-  return ::mlir::StringAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::string StringAttr::str(void) const {
-  auto val = underlying_repr().str();
-  return val;
-}
-
-size_t StringAttr::size(void) const {
-  auto val = underlying_repr().size();
-  return val;
-}
-
-bool StringAttr::empty(void) const {
-  auto val = underlying_repr().empty();
-  return val;
-}
-
-std::string_view StringAttr::value(void) const {
-  auto val = underlying_repr().getValue();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type StringAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<SymbolRefAttr> SymbolRefAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_SYMBOL_REF) {
-    return reinterpret_cast<const SymbolRefAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::SymbolRefAttr SymbolRefAttr::underlying_repr(void) const noexcept {
-  return ::mlir::SymbolRefAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<TypeAttr> TypeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_TYPE) {
-    return reinterpret_cast<const TypeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::TypeAttr TypeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::TypeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<UnitAttr> UnitAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_UNIT) {
-    return reinterpret_cast<const UnitAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::UnitAttr UnitAttr::underlying_repr(void) const noexcept {
-  return ::mlir::UnitAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<BoolAttr> BoolAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_BOOL) {
-    return reinterpret_cast<const BoolAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::BoolAttr BoolAttr::underlying_repr(void) const noexcept {
-  return ::mlir::BoolAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool BoolAttr::value(void) const {
-  auto val = underlying_repr().getValue();
-  return val;
-}
-
-std::optional<FlatSymbolRefAttr> FlatSymbolRefAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_FLAT_SYMBOL_REF) {
-    return reinterpret_cast<const FlatSymbolRefAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::FlatSymbolRefAttr FlatSymbolRefAttr::underlying_repr(void) const noexcept {
-  return ::mlir::FlatSymbolRefAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DenseIntElementsAttr> DenseIntElementsAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_DENSE_INT_ELEMENTS) {
-    return reinterpret_cast<const DenseIntElementsAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::DenseIntElementsAttr DenseIntElementsAttr::underlying_repr(void) const noexcept {
-  return ::mlir::DenseIntElementsAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DataLayoutSpecAttr> DataLayoutSpecAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::BUILTIN_DATA_LAYOUT_SPEC) {
-    return reinterpret_cast<const DataLayoutSpecAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::DataLayoutSpecAttr DataLayoutSpecAttr::underlying_repr(void) const noexcept {
-  return ::mlir::DataLayoutSpecAttr(this->::mx::ir::Attribute::attr_);
-}
-
-}  // namespace mx::ir::builtin
diff --git a/lib/IR/Builtin/Operation.cpp b/lib/IR/Builtin/Operation.cpp
deleted file mode 100644
index 074fb32ea..000000000
--- a/lib/IR/Builtin/Operation.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Operation.h>
-
-#include <multiplier/IR/Attribute.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Type.h>
-
-#include <ios>
-#include <string>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-
-namespace mx::ir::builtin {
-std::optional<Operation> Operation::from(const ::mx::ir::Operation &that) {
-  if (IsBuiltinOperationKind(that.kind())) {
-    return reinterpret_cast<const Operation &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ModuleOp> ModuleOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::BUILTIN_MODULE) {
-    return reinterpret_cast<const ModuleOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ModuleOp> ModuleOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::ModuleOp ModuleOp::underlying_repr(void) const noexcept {
-  return ::mlir::ModuleOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region ModuleOp::body_region(void) const {
-  auto &val = underlying_repr().getBodyRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<std::string_view> ModuleOp::name(void) const {
-  auto opt_val = underlying_repr().getSymName();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<std::string_view> ModuleOp::visibility(void) const {
-  auto opt_val = underlying_repr().getSymVisibility();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool ModuleOp::is_optional_symbol(void) const {
-  auto val = underlying_repr().isOptionalSymbol();
-  return val;
-}
-
-std::string_view ModuleOp::default_dialect(void) const {
-  auto val = underlying_repr().getDefaultDialect();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<UnrealizedConversionCastOp> UnrealizedConversionCastOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::BUILTIN_UNREALIZED_CONVERSION_CAST) {
-    return reinterpret_cast<const UnrealizedConversionCastOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UnrealizedConversionCastOp> UnrealizedConversionCastOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::UnrealizedConversionCastOp UnrealizedConversionCastOp::underlying_repr(void) const noexcept {
-  return ::mlir::UnrealizedConversionCastOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> UnrealizedConversionCastOp::inputs(void) const & {
-  auto range = underlying_repr().getInputs();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Result> UnrealizedConversionCastOp::outputs(void) const & {
-  auto range = underlying_repr().getOutputs();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-}  // namespace mx::ir::builtin
diff --git a/lib/IR/Builtin/Type.cpp b/lib/IR/Builtin/Type.cpp
deleted file mode 100644
index eb4e907f4..000000000
--- a/lib/IR/Builtin/Type.cpp
+++ /dev/null
@@ -1,425 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Builtin/Type.h>
-
-#include <multiplier/IR/Attribute.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-
-namespace mx::ir::builtin {
-std::optional<Type> Type::from(const ::mx::ir::Type &that) {
-  if (IsBuiltinTypeKind(that.kind())) {
-    return reinterpret_cast<const Type &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ShapedType> ShapedType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_SHAPED) {
-    return reinterpret_cast<const ShapedType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::ShapedType ShapedType::underlying_repr(void) const noexcept {
-  return ::mlir::ShapedType(this->::mx::ir::Type::type_);
-}
-
-::mx::ir::Type ShapedType::element_type(void) const {
-  auto mlir_type = underlying_repr().getElementType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-bool ShapedType::has_rank(void) const {
-  auto val = underlying_repr().hasRank();
-  return val;
-}
-
-unsigned int ShapedType::element_type_bit_width(void) const {
-  auto val = underlying_repr().getElementTypeBitWidth();
-  return val;
-}
-
-int64_t ShapedType::rank(void) const {
-  auto val = underlying_repr().getRank();
-  return val;
-}
-
-int64_t ShapedType::num_elements(void) const {
-  auto val = underlying_repr().getNumElements();
-  return val;
-}
-
-bool ShapedType::has_static_shape(void) const {
-  auto val = underlying_repr().hasStaticShape();
-  return val;
-}
-
-int64_t ShapedType::num_dynamic_dims(void) const {
-  auto val = underlying_repr().getNumDynamicDims();
-  return val;
-}
-
-std::optional<FloatType> FloatType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT) {
-    return reinterpret_cast<const FloatType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::FloatType FloatType::underlying_repr(void) const noexcept {
-  return ::mlir::FloatType(this->::mx::ir::Type::type_);
-}
-
-unsigned int FloatType::width(void) const {
-  auto val = underlying_repr().getWidth();
-  return val;
-}
-
-unsigned int FloatType::fp_mantissa_width(void) const {
-  auto val = underlying_repr().getFPMantissaWidth();
-  return val;
-}
-
-std::optional<ComplexType> ComplexType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_COMPLEX) {
-    return reinterpret_cast<const ComplexType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::ComplexType ComplexType::underlying_repr(void) const noexcept {
-  return ::mlir::ComplexType(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float8E5M2Type> Float8E5M2Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT8_E5_M2) {
-    return reinterpret_cast<const Float8E5M2Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float8E5M2Type Float8E5M2Type::underlying_repr(void) const noexcept {
-  return ::mlir::Float8E5M2Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float8E4M3FNType> Float8E4M3FNType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT8_E4_M3_FN) {
-    return reinterpret_cast<const Float8E4M3FNType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float8E4M3FNType Float8E4M3FNType::underlying_repr(void) const noexcept {
-  return ::mlir::Float8E4M3FNType(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float8E5M2FNUZType> Float8E5M2FNUZType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT8_E5_M2_FNUZ) {
-    return reinterpret_cast<const Float8E5M2FNUZType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float8E5M2FNUZType Float8E5M2FNUZType::underlying_repr(void) const noexcept {
-  return ::mlir::Float8E5M2FNUZType(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float8E4M3FNUZType> Float8E4M3FNUZType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT8_E4_M3_FNUZ) {
-    return reinterpret_cast<const Float8E4M3FNUZType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float8E4M3FNUZType Float8E4M3FNUZType::underlying_repr(void) const noexcept {
-  return ::mlir::Float8E4M3FNUZType(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float8E4M3B11FNUZType> Float8E4M3B11FNUZType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT8_E4_M3_B11_FNUZ) {
-    return reinterpret_cast<const Float8E4M3B11FNUZType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float8E4M3B11FNUZType Float8E4M3B11FNUZType::underlying_repr(void) const noexcept {
-  return ::mlir::Float8E4M3B11FNUZType(this->::mx::ir::Type::type_);
-}
-
-std::optional<BFloat16Type> BFloat16Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_B_FLOAT16) {
-    return reinterpret_cast<const BFloat16Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::BFloat16Type BFloat16Type::underlying_repr(void) const noexcept {
-  return ::mlir::BFloat16Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float16Type> Float16Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT16) {
-    return reinterpret_cast<const Float16Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float16Type Float16Type::underlying_repr(void) const noexcept {
-  return ::mlir::Float16Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<FloatTF32Type> FloatTF32Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT_TF32) {
-    return reinterpret_cast<const FloatTF32Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::FloatTF32Type FloatTF32Type::underlying_repr(void) const noexcept {
-  return ::mlir::FloatTF32Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float32Type> Float32Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT32) {
-    return reinterpret_cast<const Float32Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float32Type Float32Type::underlying_repr(void) const noexcept {
-  return ::mlir::Float32Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float64Type> Float64Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT64) {
-    return reinterpret_cast<const Float64Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float64Type Float64Type::underlying_repr(void) const noexcept {
-  return ::mlir::Float64Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float80Type> Float80Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT80) {
-    return reinterpret_cast<const Float80Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float80Type Float80Type::underlying_repr(void) const noexcept {
-  return ::mlir::Float80Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float128Type> Float128Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FLOAT128) {
-    return reinterpret_cast<const Float128Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::Float128Type Float128Type::underlying_repr(void) const noexcept {
-  return ::mlir::Float128Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<FunctionType> FunctionType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_FUNCTION) {
-    return reinterpret_cast<const FunctionType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::FunctionType FunctionType::underlying_repr(void) const noexcept {
-  return ::mlir::FunctionType(this->::mx::ir::Type::type_);
-}
-
-unsigned int FunctionType::num_inputs(void) const {
-  auto val = underlying_repr().getNumInputs();
-  return val;
-}
-
-unsigned int FunctionType::num_results(void) const {
-  auto val = underlying_repr().getNumResults();
-  return val;
-}
-
-std::optional<IndexType> IndexType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_INDEX) {
-    return reinterpret_cast<const IndexType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::IndexType IndexType::underlying_repr(void) const noexcept {
-  return ::mlir::IndexType(this->::mx::ir::Type::type_);
-}
-
-std::optional<IntegerType> IntegerType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_INTEGER) {
-    return reinterpret_cast<const IntegerType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::IntegerType IntegerType::underlying_repr(void) const noexcept {
-  return ::mlir::IntegerType(this->::mx::ir::Type::type_);
-}
-
-bool IntegerType::is_signless(void) const {
-  auto val = underlying_repr().isSignless();
-  return val;
-}
-
-bool IntegerType::is_signed(void) const {
-  auto val = underlying_repr().isSigned();
-  return val;
-}
-
-bool IntegerType::is_unsigned(void) const {
-  auto val = underlying_repr().isUnsigned();
-  return val;
-}
-
-unsigned int IntegerType::width(void) const {
-  auto val = underlying_repr().getWidth();
-  return val;
-}
-
-std::optional<MemRefType> MemRefType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_MEM_REF) {
-    return reinterpret_cast<const MemRefType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::MemRefType MemRefType::underlying_repr(void) const noexcept {
-  return ::mlir::MemRefType(this->::mx::ir::Type::type_);
-}
-
-unsigned int MemRefType::memory_space_as_int(void) const {
-  auto val = underlying_repr().getMemorySpaceAsInt();
-  return val;
-}
-
-std::optional<NoneType> NoneType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_NONE) {
-    return reinterpret_cast<const NoneType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::NoneType NoneType::underlying_repr(void) const noexcept {
-  return ::mlir::NoneType(this->::mx::ir::Type::type_);
-}
-
-std::optional<OpaqueType> OpaqueType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_OPAQUE) {
-    return reinterpret_cast<const OpaqueType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::OpaqueType OpaqueType::underlying_repr(void) const noexcept {
-  return ::mlir::OpaqueType(this->::mx::ir::Type::type_);
-}
-
-std::string_view OpaqueType::type_data(void) const {
-  auto val = underlying_repr().getTypeData();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<RankedTensorType> RankedTensorType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_RANKED_TENSOR) {
-    return reinterpret_cast<const RankedTensorType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::RankedTensorType RankedTensorType::underlying_repr(void) const noexcept {
-  return ::mlir::RankedTensorType(this->::mx::ir::Type::type_);
-}
-
-std::optional<TupleType> TupleType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_TUPLE) {
-    return reinterpret_cast<const TupleType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::TupleType TupleType::underlying_repr(void) const noexcept {
-  return ::mlir::TupleType(this->::mx::ir::Type::type_);
-}
-
-size_t TupleType::size(void) const {
-  auto val = underlying_repr().size();
-  return val;
-}
-
-std::optional<UnrankedMemRefType> UnrankedMemRefType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_UNRANKED_MEM_REF) {
-    return reinterpret_cast<const UnrankedMemRefType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::UnrankedMemRefType UnrankedMemRefType::underlying_repr(void) const noexcept {
-  return ::mlir::UnrankedMemRefType(this->::mx::ir::Type::type_);
-}
-
-unsigned int UnrankedMemRefType::memory_space_as_int(void) const {
-  auto val = underlying_repr().getMemorySpaceAsInt();
-  return val;
-}
-
-std::optional<UnrankedTensorType> UnrankedTensorType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_UNRANKED_TENSOR) {
-    return reinterpret_cast<const UnrankedTensorType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::UnrankedTensorType UnrankedTensorType::underlying_repr(void) const noexcept {
-  return ::mlir::UnrankedTensorType(this->::mx::ir::Type::type_);
-}
-
-std::optional<VectorType> VectorType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::BUILTIN_VECTOR) {
-    return reinterpret_cast<const VectorType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::VectorType VectorType::underlying_repr(void) const noexcept {
-  return ::mlir::VectorType(this->::mx::ir::Type::type_);
-}
-
-bool VectorType::is_scalable(void) const {
-  auto val = underlying_repr().isScalable();
-  return val;
-}
-
-bool VectorType::all_dims_scalable(void) const {
-  auto val = underlying_repr().allDimsScalable();
-  return val;
-}
-
-bool VectorType::has_rank(void) const {
-  auto val = underlying_repr().hasRank();
-  return val;
-}
-
-}  // namespace mx::ir::builtin
diff --git a/lib/IR/Core/Attribute.cpp b/lib/IR/Core/Attribute.cpp
deleted file mode 100644
index 156e4d3d3..000000000
--- a/lib/IR/Core/Attribute.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Attribute.h>
-
-#include <multiplier/IR/Type.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <mlir/Dialect/MemRef/IR/MemRef.h>
-#include <vast/Dialect/Dialects.hpp>
-
-namespace mx::ir::core {
-std::optional<Attribute> Attribute::from(const ::mx::ir::Attribute &that) {
-  if (IsCoreAttributeKind(that.kind())) {
-    return reinterpret_cast<const Attribute &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BooleanAttr> BooleanAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::CORE_BOOLEAN) {
-    return reinterpret_cast<const BooleanAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::core::BooleanAttr BooleanAttr::underlying_repr(void) const noexcept {
-  return ::vast::core::BooleanAttr(this->::mx::ir::Attribute::attr_);
-}
-
-::mx::ir::Type BooleanAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-bool BooleanAttr::value(void) const {
-  auto val = underlying_repr().getValue();
-  return val;
-}
-
-std::optional<IntegerAttr> IntegerAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::CORE_INTEGER) {
-    return reinterpret_cast<const IntegerAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::core::IntegerAttr IntegerAttr::underlying_repr(void) const noexcept {
-  return ::vast::core::IntegerAttr(this->::mx::ir::Attribute::attr_);
-}
-
-::mx::ir::Type IntegerAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<FloatAttr> FloatAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::CORE_FLOAT) {
-    return reinterpret_cast<const FloatAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::core::FloatAttr FloatAttr::underlying_repr(void) const noexcept {
-  return ::vast::core::FloatAttr(this->::mx::ir::Attribute::attr_);
-}
-
-::mx::ir::Type FloatAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<VoidAttr> VoidAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::CORE_VOID) {
-    return reinterpret_cast<const VoidAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::core::VoidAttr VoidAttr::underlying_repr(void) const noexcept {
-  return ::vast::core::VoidAttr(this->::mx::ir::Attribute::attr_);
-}
-
-::mx::ir::Type VoidAttr::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<SourceLanguageAttr> SourceLanguageAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::CORE_SOURCE_LANGUAGE) {
-    return reinterpret_cast<const SourceLanguageAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::core::SourceLanguageAttr SourceLanguageAttr::underlying_repr(void) const noexcept {
-  return ::vast::core::SourceLanguageAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<GlobalLinkageKindAttr> GlobalLinkageKindAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::CORE_GLOBAL_LINKAGE_KIND) {
-    return reinterpret_cast<const GlobalLinkageKindAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::core::GlobalLinkageKindAttr GlobalLinkageKindAttr::underlying_repr(void) const noexcept {
-  return ::vast::core::GlobalLinkageKindAttr(this->::mx::ir::Attribute::attr_);
-}
-
-}  // namespace mx::ir::core
diff --git a/lib/IR/Core/Operation.cpp b/lib/IR/Core/Operation.cpp
deleted file mode 100644
index 796ad4279..000000000
--- a/lib/IR/Core/Operation.cpp
+++ /dev/null
@@ -1,262 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Operation.h>
-
-#include <multiplier/IR/Attribute.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Type.h>
-
-#include <ios>
-#include <string>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/HighLevel/HighLevelOps.hpp>
-
-namespace mx::ir::core {
-std::optional<Operation> Operation::from(const ::mx::ir::Operation &that) {
-  if (IsCoreOperationKind(that.kind())) {
-    return reinterpret_cast<const Operation &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinLAndOp> BinLAndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::CORE_BIN_LAND) {
-    return reinterpret_cast<const BinLAndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinLAndOp> BinLAndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::core::BinLAndOp BinLAndOp::underlying_repr(void) const noexcept {
-  return ::vast::core::BinLAndOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinLAndOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinLAndOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinLAndOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinLOrOp> BinLOrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::CORE_BIN_LOR) {
-    return reinterpret_cast<const BinLOrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinLOrOp> BinLOrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::core::BinLOrOp BinLOrOp::underlying_repr(void) const noexcept {
-  return ::vast::core::BinLOrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinLOrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinLOrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinLOrOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ImplicitReturnOp> ImplicitReturnOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::CORE_IMPLICIT_RETURN) {
-    return reinterpret_cast<const ImplicitReturnOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ImplicitReturnOp> ImplicitReturnOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::core::ImplicitReturnOp ImplicitReturnOp::underlying_repr(void) const noexcept {
-  return ::vast::core::ImplicitReturnOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> ImplicitReturnOp::result(void) const & {
-  auto range = underlying_repr().getResult();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<LazyOp> LazyOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::CORE_LAZY_OP) {
-    return reinterpret_cast<const LazyOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LazyOp> LazyOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::core::LazyOp LazyOp::underlying_repr(void) const noexcept {
-  return ::vast::core::LazyOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value LazyOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region LazyOp::lazy(void) const {
-  auto &val = underlying_repr().getLazy();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<ModuleOp> ModuleOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::CORE_MODULE) {
-    return reinterpret_cast<const ModuleOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ModuleOp> ModuleOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::core::ModuleOp ModuleOp::underlying_repr(void) const noexcept {
-  return ::vast::core::ModuleOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region ModuleOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<std::string_view> ModuleOp::name(void) const {
-  auto opt_val = underlying_repr().getSymName();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool ModuleOp::is_optional_symbol(void) const {
-  auto val = underlying_repr().isOptionalSymbol();
-  return val;
-}
-
-std::string_view ModuleOp::default_dialect(void) const {
-  auto val = underlying_repr().getDefaultDialect();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<ScopeOp> ScopeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::CORE_SCOPE) {
-    return reinterpret_cast<const ScopeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ScopeOp> ScopeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::core::ScopeOp ScopeOp::underlying_repr(void) const noexcept {
-  return ::vast::core::ScopeOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region ScopeOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<SelectOp> SelectOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::CORE_SELECT) {
-    return reinterpret_cast<const SelectOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SelectOp> SelectOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::core::SelectOp SelectOp::underlying_repr(void) const noexcept {
-  return ::vast::core::SelectOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SelectOp::cond(void) const {
-  auto val = underlying_repr().getCond();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SelectOp::then_region(void) const {
-  auto val = underlying_repr().getThenRegion();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SelectOp::else_region(void) const {
-  auto val = underlying_repr().getElseRegion();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Result> SelectOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-}  // namespace mx::ir::core
diff --git a/lib/IR/Core/Type.cpp b/lib/IR/Core/Type.cpp
deleted file mode 100644
index 0e57d3b9b..000000000
--- a/lib/IR/Core/Type.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Core/Type.h>
-
-#include <multiplier/IR/Attribute.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <vast/Dialect/ABI/ABIOps.hpp>
-
-namespace mx::ir::core {
-std::optional<Type> Type::from(const ::mx::ir::Type &that) {
-  if (IsCoreTypeKind(that.kind())) {
-    return reinterpret_cast<const Type &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FunctionType> FunctionType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::CORE_FUNCTION) {
-    return reinterpret_cast<const FunctionType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::core::FunctionType FunctionType::underlying_repr(void) const noexcept {
-  return ::vast::core::FunctionType(this->::mx::ir::Type::type_);
-}
-
-bool FunctionType::is_var_arg(void) const {
-  auto val = underlying_repr().isVarArg();
-  return val;
-}
-
-unsigned int FunctionType::num_inputs(void) const {
-  auto val = underlying_repr().getNumInputs();
-  return val;
-}
-
-unsigned int FunctionType::num_results(void) const {
-  auto val = underlying_repr().getNumResults();
-  return val;
-}
-
-gap::generator<::mx::ir::Type> FunctionType::inputs(void) const & {
-  auto range = underlying_repr().getInputs();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-gap::generator<::mx::ir::Type> FunctionType::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-bool FunctionType::var_arg(void) const {
-  auto val = underlying_repr().getVarArg();
-  return val;
-}
-
-}  // namespace mx::ir::core
diff --git a/lib/IR/HighLevel/Attribute.cpp b/lib/IR/HighLevel/Attribute.cpp
deleted file mode 100644
index ce848e0cf..000000000
--- a/lib/IR/HighLevel/Attribute.cpp
+++ /dev/null
@@ -1,589 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Attribute.h>
-
-#include <multiplier/IR/Type.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/ABI/ABIOps.hpp>
-
-namespace mx::ir::hl {
-std::optional<Attribute> Attribute::from(const ::mx::ir::Attribute &that) {
-  if (IsHighLevelAttributeKind(that.kind())) {
-    return reinterpret_cast<const Attribute &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AnnotationAttr> AnnotationAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_ANNOTATION) {
-    return reinterpret_cast<const AnnotationAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AnnotationAttr AnnotationAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AnnotationAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<FormatAttr> FormatAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_FORMAT) {
-    return reinterpret_cast<const FormatAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::FormatAttr FormatAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::FormatAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<SectionAttr> SectionAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_SECTION) {
-    return reinterpret_cast<const SectionAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::SectionAttr SectionAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::SectionAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<AliasAttr> AliasAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_ALIAS) {
-    return reinterpret_cast<const AliasAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AliasAttr AliasAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AliasAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<ErrorAttr> ErrorAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_ERROR) {
-    return reinterpret_cast<const ErrorAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ErrorAttr ErrorAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::ErrorAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<CountedByAttr> CountedByAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_COUNTED_BY) {
-    return reinterpret_cast<const CountedByAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CountedByAttr CountedByAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::CountedByAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<CleanupAttr> CleanupAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_CLEANUP) {
-    return reinterpret_cast<const CleanupAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CleanupAttr CleanupAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::CleanupAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<AlignedAttr> AlignedAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_ALIGNED) {
-    return reinterpret_cast<const AlignedAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AlignedAttr AlignedAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AlignedAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<AlwaysInlineAttr> AlwaysInlineAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_ALWAYS_INLINE) {
-    return reinterpret_cast<const AlwaysInlineAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AlwaysInlineAttr AlwaysInlineAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AlwaysInlineAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<NoInlineAttr> NoInlineAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_NO_INLINE) {
-    return reinterpret_cast<const NoInlineAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::NoInlineAttr NoInlineAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::NoInlineAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<ConstAttr> ConstAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_CONST) {
-    return reinterpret_cast<const ConstAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ConstAttr ConstAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::ConstAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoaderUninitializedAttr> LoaderUninitializedAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_LOADER_UNINITIALIZED) {
-    return reinterpret_cast<const LoaderUninitializedAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LoaderUninitializedAttr LoaderUninitializedAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::LoaderUninitializedAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<NoInstrumentFunctionAttr> NoInstrumentFunctionAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_NO_INSTRUMENT_FUNCTION) {
-    return reinterpret_cast<const NoInstrumentFunctionAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::NoInstrumentFunctionAttr NoInstrumentFunctionAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::NoInstrumentFunctionAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<PackedAttr> PackedAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_PACKED) {
-    return reinterpret_cast<const PackedAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PackedAttr PackedAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::PackedAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<PureAttr> PureAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_PURE) {
-    return reinterpret_cast<const PureAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PureAttr PureAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::PureAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<WarnUnusedResultAttr> WarnUnusedResultAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_WARN_UNUSED_RESULT) {
-    return reinterpret_cast<const WarnUnusedResultAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::WarnUnusedResultAttr WarnUnusedResultAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::WarnUnusedResultAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<RestrictAttr> RestrictAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_RESTRICT) {
-    return reinterpret_cast<const RestrictAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RestrictAttr RestrictAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::RestrictAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<NoThrowAttr> NoThrowAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_NO_THROW) {
-    return reinterpret_cast<const NoThrowAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::NoThrowAttr NoThrowAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::NoThrowAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<NonNullAttr> NonNullAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_NON_NULL) {
-    return reinterpret_cast<const NonNullAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::NonNullAttr NonNullAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::NonNullAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LeafAttr> LeafAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_LEAF) {
-    return reinterpret_cast<const LeafAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LeafAttr LeafAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::LeafAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<ColdAttr> ColdAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_COLD) {
-    return reinterpret_cast<const ColdAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ColdAttr ColdAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::ColdAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<TransparentUnionAttr> TransparentUnionAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_TRANSPARENT_UNION) {
-    return reinterpret_cast<const TransparentUnionAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TransparentUnionAttr TransparentUnionAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::TransparentUnionAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<ReturnsTwiceAttr> ReturnsTwiceAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_RETURNS_TWICE) {
-    return reinterpret_cast<const ReturnsTwiceAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ReturnsTwiceAttr ReturnsTwiceAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::ReturnsTwiceAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<MayAliasAttr> MayAliasAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_MAY_ALIAS) {
-    return reinterpret_cast<const MayAliasAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::MayAliasAttr MayAliasAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::MayAliasAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<UnusedAttr> UnusedAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_UNUSED) {
-    return reinterpret_cast<const UnusedAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::UnusedAttr UnusedAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::UnusedAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<UsedAttr> UsedAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_USED) {
-    return reinterpret_cast<const UsedAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::UsedAttr UsedAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::UsedAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<GNUInlineAttr> GNUInlineAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_GNU_INLINE) {
-    return reinterpret_cast<const GNUInlineAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::GNUInlineAttr GNUInlineAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::GNUInlineAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<NoCfCheckAttr> NoCfCheckAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_NO_CF_CHECK) {
-    return reinterpret_cast<const NoCfCheckAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::NoCfCheckAttr NoCfCheckAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::NoCfCheckAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<AvailableOnlyInDefaultEvalMethodAttr> AvailableOnlyInDefaultEvalMethodAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_AVAILABLE_ONLY_IN_DEFAULT_EVAL_METHOD) {
-    return reinterpret_cast<const AvailableOnlyInDefaultEvalMethodAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AvailableOnlyInDefaultEvalMethodAttr AvailableOnlyInDefaultEvalMethodAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AvailableOnlyInDefaultEvalMethodAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<AvailabilityAttrAttr> AvailabilityAttrAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_AVAILABILITY_ATTR) {
-    return reinterpret_cast<const AvailabilityAttrAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AvailabilityAttrAttr AvailabilityAttrAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AvailabilityAttrAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<FallthroughAttr> FallthroughAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_FALLTHROUGH) {
-    return reinterpret_cast<const FallthroughAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::FallthroughAttr FallthroughAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::FallthroughAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<NoProfileInstrumentFunctionAttr> NoProfileInstrumentFunctionAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_NO_PROFILE_INSTRUMENT_FUNCTION) {
-    return reinterpret_cast<const NoProfileInstrumentFunctionAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::NoProfileInstrumentFunctionAttr NoProfileInstrumentFunctionAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::NoProfileInstrumentFunctionAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<AsmLabelAttr> AsmLabelAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_ASM_LABEL) {
-    return reinterpret_cast<const AsmLabelAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AsmLabelAttr AsmLabelAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AsmLabelAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool AsmLabelAttr::is_literal(void) const {
-  auto val = underlying_repr().getIsLiteral();
-  return val;
-}
-
-std::optional<ModeAttr> ModeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_MODE) {
-    return reinterpret_cast<const ModeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ModeAttr ModeAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::ModeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<BuiltinAttr> BuiltinAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_BUILTIN) {
-    return reinterpret_cast<const BuiltinAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BuiltinAttr BuiltinAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::BuiltinAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int BuiltinAttr::id(void) const {
-  auto val = underlying_repr().getID();
-  return val;
-}
-
-std::optional<AllocAlignAttr> AllocAlignAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_ALLOC_ALIGN) {
-    return reinterpret_cast<const AllocAlignAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AllocAlignAttr AllocAlignAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AllocAlignAttr(this->::mx::ir::Attribute::attr_);
-}
-
-int AllocAlignAttr::alignment(void) const {
-  auto val = underlying_repr().getAlignment();
-  return val;
-}
-
-std::optional<AllocSizeAttr> AllocSizeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_ALLOC_SIZE) {
-    return reinterpret_cast<const AllocSizeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AllocSizeAttr AllocSizeAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AllocSizeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-int AllocSizeAttr::size_arg_pos(void) const {
-  auto val = underlying_repr().getSizeArgPos();
-  return val;
-}
-
-int AllocSizeAttr::num_arg_pos(void) const {
-  auto val = underlying_repr().getNumArgPos();
-  return val;
-}
-
-std::optional<DeprecatedAttr> DeprecatedAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_DEPRECATED) {
-    return reinterpret_cast<const DeprecatedAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DeprecatedAttr DeprecatedAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::DeprecatedAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<MaxFieldAlignmentAttr> MaxFieldAlignmentAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_MAX_FIELD_ALIGNMENT) {
-    return reinterpret_cast<const MaxFieldAlignmentAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::MaxFieldAlignmentAttr MaxFieldAlignmentAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::MaxFieldAlignmentAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int MaxFieldAlignmentAttr::alignment(void) const {
-  auto val = underlying_repr().getAlignment();
-  return val;
-}
-
-std::optional<VisibilityAttr> VisibilityAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_VISIBILITY) {
-    return reinterpret_cast<const VisibilityAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::VisibilityAttr VisibilityAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::VisibilityAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<AssumeAlignedAttr> AssumeAlignedAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_ASSUME_ALIGNED) {
-    return reinterpret_cast<const AssumeAlignedAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AssumeAlignedAttr AssumeAlignedAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::AssumeAlignedAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<CVQualifiersAttr> CVQualifiersAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_CV_QUALIFIERS) {
-    return reinterpret_cast<const CVQualifiersAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CVQualifiersAttr CVQualifiersAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::CVQualifiersAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool CVQualifiersAttr::is_const(void) const {
-  auto val = underlying_repr().getIsConst();
-  return val;
-}
-
-bool CVQualifiersAttr::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-std::optional<UCVQualifiersAttr> UCVQualifiersAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_UCV_QUALIFIERS) {
-    return reinterpret_cast<const UCVQualifiersAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::UCVQualifiersAttr UCVQualifiersAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::UCVQualifiersAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool UCVQualifiersAttr::is_unsigned(void) const {
-  auto val = underlying_repr().getIsUnsigned();
-  return val;
-}
-
-bool UCVQualifiersAttr::is_const(void) const {
-  auto val = underlying_repr().getIsConst();
-  return val;
-}
-
-bool UCVQualifiersAttr::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-std::optional<CVRQualifiersAttr> CVRQualifiersAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_CVR_QUALIFIERS) {
-    return reinterpret_cast<const CVRQualifiersAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CVRQualifiersAttr CVRQualifiersAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::CVRQualifiersAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool CVRQualifiersAttr::is_const(void) const {
-  auto val = underlying_repr().getIsConst();
-  return val;
-}
-
-bool CVRQualifiersAttr::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-bool CVRQualifiersAttr::is_restrict(void) const {
-  auto val = underlying_repr().getIsRestrict();
-  return val;
-}
-
-std::optional<OffsetOfNodeAttr> OffsetOfNodeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::HL_OFFSET_OF_NODE) {
-    return reinterpret_cast<const OffsetOfNodeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::OffsetOfNodeAttr OffsetOfNodeAttr::underlying_repr(void) const noexcept {
-  return ::vast::hl::OffsetOfNodeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-}  // namespace mx::ir::hl
diff --git a/lib/IR/HighLevel/Operation.cpp b/lib/IR/HighLevel/Operation.cpp
deleted file mode 100644
index 693218707..000000000
--- a/lib/IR/HighLevel/Operation.cpp
+++ /dev/null
@@ -1,4385 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Operation.h>
-
-#include <multiplier/IR/Attribute.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Type.h>
-
-#include <ios>
-#include <string>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <mlir/Dialect/MemRef/IR/MemRef.h>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/ABI/ABIOps.hpp>
-#include <vast/Dialect/HighLevel/HighLevelOps.hpp>
-
-namespace mx::ir::hl {
-std::optional<Operation> Operation::from(const ::mx::ir::Operation &that) {
-  if (IsHighLevelOperationKind(that.kind())) {
-    return reinterpret_cast<const Operation &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AccessSpecifierOp> AccessSpecifierOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ACCESS) {
-    return reinterpret_cast<const AccessSpecifierOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AccessSpecifierOp> AccessSpecifierOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AccessSpecifierOp AccessSpecifierOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AccessSpecifierOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<AddFAssignOp> AddFAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_FADD) {
-    return reinterpret_cast<const AddFAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AddFAssignOp> AddFAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AddFAssignOp AddFAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AddFAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AddFAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddFAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddFAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AddFOp> AddFOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FADD) {
-    return reinterpret_cast<const AddFOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AddFOp> AddFOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AddFOp AddFOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AddFOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AddFOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddFOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddFOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AddIAssignOp> AddIAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_ADD) {
-    return reinterpret_cast<const AddIAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AddIAssignOp> AddIAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AddIAssignOp AddIAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AddIAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AddIAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddIAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddIAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AddIOp> AddIOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ADD) {
-    return reinterpret_cast<const AddIOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AddIOp> AddIOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AddIOp AddIOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AddIOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AddIOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddIOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddIOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AddrLabelExprOp> AddrLabelExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_LABELADDR) {
-    return reinterpret_cast<const AddrLabelExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AddrLabelExprOp> AddrLabelExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AddrLabelExpr AddrLabelExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AddrLabelExpr(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AddrLabelExprOp::label(void) const {
-  auto val = underlying_repr().getLabel();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddrLabelExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AddressOfOp> AddressOfOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ADDRESSOF) {
-    return reinterpret_cast<const AddressOfOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AddressOfOp> AddressOfOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AddressOf AddressOfOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AddressOf(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AddressOfOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddressOfOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AlignOfExprOp> AlignOfExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ALIGNOF_EXPR) {
-    return reinterpret_cast<const AlignOfExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AlignOfExprOp> AlignOfExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AlignOfExprOp AlignOfExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AlignOfExprOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AlignOfExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region AlignOfExprOp::expression(void) const {
-  auto &val = underlying_repr().getExpr();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<AlignOfTypeOp> AlignOfTypeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ALIGNOF_TYPE) {
-    return reinterpret_cast<const AlignOfTypeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AlignOfTypeOp> AlignOfTypeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AlignOfTypeOp AlignOfTypeOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AlignOfTypeOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AlignOfTypeOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Type AlignOfTypeOp::argument(void) const {
-  auto mlir_type = underlying_repr().getArg();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<AsmOp> AsmOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASM) {
-    return reinterpret_cast<const AsmOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AsmOp> AsmOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AsmOp AsmOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AsmOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> AsmOp::asm_outputs(void) const & {
-  auto range = underlying_repr().getAsmOutputs();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> AsmOp::asm_inputs(void) const & {
-  auto range = underlying_repr().getAsmInputs();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> AsmOp::labels(void) const & {
-  auto range = underlying_repr().getLabels();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::string_view AsmOp::asm_template(void) const {
-  auto val = underlying_repr().getAsmTemplate();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool AsmOp::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-bool AsmOp::has_goto(void) const {
-  auto val = underlying_repr().getHasGoto();
-  return val;
-}
-
-std::optional<AssignOp> AssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN) {
-    return reinterpret_cast<const AssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AssignOp> AssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AssignOp AssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AttributedStmtOp> AttributedStmtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ATTRIBUTED_STMT) {
-    return reinterpret_cast<const AttributedStmtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AttributedStmtOp> AttributedStmtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AttributedStmt AttributedStmtOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::AttributedStmt(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region AttributedStmtOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<BinAShrAssignOp> BinAShrAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_BIN_ASHR) {
-    return reinterpret_cast<const BinAShrAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinAShrAssignOp> BinAShrAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinAShrAssignOp BinAShrAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinAShrAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinAShrAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinAShrAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinAShrAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinAShrOp> BinAShrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BIN_ASHR) {
-    return reinterpret_cast<const BinAShrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinAShrOp> BinAShrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinAShrOp BinAShrOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinAShrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinAShrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinAShrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinAShrOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinAndAssignOp> BinAndAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_BIN_AND) {
-    return reinterpret_cast<const BinAndAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinAndAssignOp> BinAndAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinAndAssignOp BinAndAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinAndAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinAndAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinAndAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinAndAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinAndOp> BinAndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BIN_AND) {
-    return reinterpret_cast<const BinAndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinAndOp> BinAndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinAndOp BinAndOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinAndOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinAndOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinAndOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinAndOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinCommaOp> BinCommaOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BIN_COMMA) {
-    return reinterpret_cast<const BinCommaOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinCommaOp> BinCommaOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinComma BinCommaOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinComma(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinCommaOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinCommaOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinCommaOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinLAndOp> BinLAndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BIN_LAND) {
-    return reinterpret_cast<const BinLAndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinLAndOp> BinLAndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinLAndOp BinLAndOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinLAndOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinLAndOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region BinLAndOp::left(void) const {
-  auto &val = underlying_repr().getLhs();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region BinLAndOp::right(void) const {
-  auto &val = underlying_repr().getRhs();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<BinLOrOp> BinLOrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BIN_LOR) {
-    return reinterpret_cast<const BinLOrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinLOrOp> BinLOrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinLOrOp BinLOrOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinLOrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinLOrOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region BinLOrOp::left(void) const {
-  auto &val = underlying_repr().getLhs();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region BinLOrOp::right(void) const {
-  auto &val = underlying_repr().getRhs();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<BinLShrAssignOp> BinLShrAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_BIN_LSHR) {
-    return reinterpret_cast<const BinLShrAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinLShrAssignOp> BinLShrAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinLShrAssignOp BinLShrAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinLShrAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinLShrAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinLShrAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinLShrAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinLShrOp> BinLShrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BIN_LSHR) {
-    return reinterpret_cast<const BinLShrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinLShrOp> BinLShrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinLShrOp BinLShrOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinLShrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinLShrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinLShrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinLShrOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinOrAssignOp> BinOrAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_BIN_OR) {
-    return reinterpret_cast<const BinOrAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinOrAssignOp> BinOrAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinOrAssignOp BinOrAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinOrAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinOrAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinOrAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinOrAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinOrOp> BinOrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BIN_OR) {
-    return reinterpret_cast<const BinOrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinOrOp> BinOrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinOrOp BinOrOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinOrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinOrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinOrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinOrOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinShlAssignOp> BinShlAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_BIN_SHL) {
-    return reinterpret_cast<const BinShlAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinShlAssignOp> BinShlAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinShlAssignOp BinShlAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinShlAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinShlAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinShlAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinShlAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinShlOp> BinShlOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BIN_SHL) {
-    return reinterpret_cast<const BinShlOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinShlOp> BinShlOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinShlOp BinShlOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinShlOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinShlOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinShlOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinShlOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinXorAssignOp> BinXorAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_BIN_XOR) {
-    return reinterpret_cast<const BinXorAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinXorAssignOp> BinXorAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinXorAssignOp BinXorAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinXorAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinXorAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinXorAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinXorAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinXorOp> BinXorOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BIN_XOR) {
-    return reinterpret_cast<const BinXorOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinXorOp> BinXorOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinXorOp BinXorOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinXorOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinXorOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinXorOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BinXorOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BinaryCondOp> BinaryCondOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BINARY_COND) {
-    return reinterpret_cast<const BinaryCondOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BinaryCondOp> BinaryCondOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BinaryCondOp BinaryCondOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BinaryCondOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BinaryCondOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<::mx::ir::Region> BinaryCondOp::common_region(void) const {
-  decltype(auto) opt_val = underlying_repr().getCommonRegion();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region BinaryCondOp::condition_region(void) const {
-  auto &val = underlying_repr().getCondRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region BinaryCondOp::then_region(void) const {
-  auto &val = underlying_repr().getThenRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region BinaryCondOp::else_region(void) const {
-  auto &val = underlying_repr().getElseRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<BreakOp> BreakOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BREAK) {
-    return reinterpret_cast<const BreakOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BreakOp> BreakOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BreakOp BreakOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BreakOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<BuiltinBitCastOp> BuiltinBitCastOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BUILTIN_BITCAST) {
-    return reinterpret_cast<const BuiltinBitCastOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BuiltinBitCastOp> BuiltinBitCastOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BuiltinBitCastOp BuiltinBitCastOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BuiltinBitCastOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BuiltinBitCastOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BuiltinBitCastOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BuiltinTypesCompatiblePOp> BuiltinTypesCompatiblePOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BUILTIN_TYPES_COMPATIBLE_P_TYPE) {
-    return reinterpret_cast<const BuiltinTypesCompatiblePOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BuiltinTypesCompatiblePOp> BuiltinTypesCompatiblePOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BuiltinTypesCompatiblePOp BuiltinTypesCompatiblePOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::BuiltinTypesCompatiblePOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BuiltinTypesCompatiblePOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Type BuiltinTypesCompatiblePOp::type1(void) const {
-  auto mlir_type = underlying_repr().getType1();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-::mx::ir::Type BuiltinTypesCompatiblePOp::type2(void) const {
-  auto mlir_type = underlying_repr().getType2();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-bool BuiltinTypesCompatiblePOp::compatible(void) const {
-  auto val = underlying_repr().getCompatible();
-  return val;
-}
-
-gap::generator<::mx::ir::Type> BuiltinTypesCompatiblePOp::arguments(void) const & {
-  auto range = underlying_repr().getArgs();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-std::optional<bool> BuiltinTypesCompatiblePOp::value(void) const {
-  auto opt_val = underlying_repr().getValue();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<CStyleCastOp> CStyleCastOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CSTYLE_CAST) {
-    return reinterpret_cast<const CStyleCastOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CStyleCastOp> CStyleCastOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CStyleCastOp CStyleCastOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::CStyleCastOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CStyleCastOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CStyleCastOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CallOp> CallOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CALL) {
-    return reinterpret_cast<const CallOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CallOp> CallOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CallOp CallOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::CallOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> CallOp::arg_operands(void) const & {
-  auto range = underlying_repr().getArgOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Result> CallOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::string_view CallOp::callee(void) const {
-  auto val = underlying_repr().getCallee();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<CaseOp> CaseOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CASE) {
-    return reinterpret_cast<const CaseOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CaseOp> CaseOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CaseOp CaseOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::CaseOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region CaseOp::left(void) const {
-  auto &val = underlying_repr().getLhs();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<::mx::ir::Region> CaseOp::body(void) const {
-  decltype(auto) opt_val = underlying_repr().getBody();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<ChooseExprOp> ChooseExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CHOOSE_EXPR) {
-    return reinterpret_cast<const ChooseExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ChooseExprOp> ChooseExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ChooseExprOp ChooseExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ChooseExprOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ChooseExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region ChooseExprOp::condition_region(void) const {
-  auto &val = underlying_repr().getCondRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region ChooseExprOp::then_region(void) const {
-  auto &val = underlying_repr().getThenRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region ChooseExprOp::else_region(void) const {
-  auto &val = underlying_repr().getElseRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<bool> ChooseExprOp::cond_true(void) const {
-  auto opt_val = underlying_repr().getCondTrue();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<bool> ChooseExprOp::is_condition_true(void) const {
-  auto opt_val = underlying_repr().isConditionTrue();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-bool ChooseExprOp::is_condition_dependent(void) const {
-  auto val = underlying_repr().isConditionDependent();
-  return val;
-}
-
-std::optional<ClassDeclOp> ClassDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CLASS) {
-    return reinterpret_cast<const ClassDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ClassDeclOp> ClassDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ClassDeclOp ClassDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ClassDeclOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region ClassDeclOp::bases(void) const {
-  auto &val = underlying_repr().getBases();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region ClassDeclOp::fields(void) const {
-  auto &val = underlying_repr().getFields();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view ClassDeclOp::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<CmpOp> CmpOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CMP) {
-    return reinterpret_cast<const CmpOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CmpOp> CmpOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CmpOp CmpOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::CmpOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CmpOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CmpOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CmpOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CompoundLiteralOp> CompoundLiteralOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_COMPOUND_LITERAL) {
-    return reinterpret_cast<const CompoundLiteralOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CompoundLiteralOp> CompoundLiteralOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CompoundLiteralOp CompoundLiteralOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::CompoundLiteralOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CompoundLiteralOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region CompoundLiteralOp::initializer(void) const {
-  auto &val = underlying_repr().getInit();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<CondOp> CondOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_COND) {
-    return reinterpret_cast<const CondOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CondOp> CondOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CondOp CondOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::CondOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CondOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region CondOp::condition_region(void) const {
-  auto &val = underlying_repr().getCondRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region CondOp::then_region(void) const {
-  auto &val = underlying_repr().getThenRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region CondOp::else_region(void) const {
-  auto &val = underlying_repr().getElseRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<CondYieldOp> CondYieldOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_COND_YIELD) {
-    return reinterpret_cast<const CondYieldOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CondYieldOp> CondYieldOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CondYieldOp CondYieldOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::CondYieldOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CondYieldOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ConstantOp> ConstantOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CONST) {
-    return reinterpret_cast<const ConstantOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ConstantOp> ConstantOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ConstantOp ConstantOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ConstantOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ConstantOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ContinueOp> ContinueOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CONTINUE) {
-    return reinterpret_cast<const ContinueOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ContinueOp> ContinueOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ContinueOp ContinueOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ContinueOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<CxxBaseSpecifierOp> CxxBaseSpecifierOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_BASE) {
-    return reinterpret_cast<const CxxBaseSpecifierOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CxxBaseSpecifierOp> CxxBaseSpecifierOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CxxBaseSpecifierOp CxxBaseSpecifierOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::CxxBaseSpecifierOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Type CxxBaseSpecifierOp::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-bool CxxBaseSpecifierOp::is_virtual(void) const {
-  auto val = underlying_repr().getIsVirtual();
-  return val;
-}
-
-std::optional<CxxStructDeclOp> CxxStructDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CXXSTRUCT) {
-    return reinterpret_cast<const CxxStructDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CxxStructDeclOp> CxxStructDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CxxStructDeclOp CxxStructDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::CxxStructDeclOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region CxxStructDeclOp::bases(void) const {
-  auto &val = underlying_repr().getBases();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region CxxStructDeclOp::fields(void) const {
-  auto &val = underlying_repr().getFields();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view CxxStructDeclOp::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<DeclRefOp> DeclRefOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_REF) {
-    return reinterpret_cast<const DeclRefOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DeclRefOp> DeclRefOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DeclRefOp DeclRefOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::DeclRefOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DeclRefOp::declaration(void) const {
-  auto val = underlying_repr().getDecl();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DeclRefOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DefaultOp> DefaultOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_DEFAULT) {
-    return reinterpret_cast<const DefaultOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DefaultOp> DefaultOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DefaultOp DefaultOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::DefaultOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<::mx::ir::Region> DefaultOp::body(void) const {
-  decltype(auto) opt_val = underlying_repr().getBody();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<DerefOp> DerefOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_DEREF) {
-    return reinterpret_cast<const DerefOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DerefOp> DerefOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::Deref DerefOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::Deref(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DerefOp::addr(void) const {
-  auto val = underlying_repr().getAddr();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DerefOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DivFAssignOp> DivFAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_FDIV) {
-    return reinterpret_cast<const DivFAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DivFAssignOp> DivFAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DivFAssignOp DivFAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::DivFAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DivFAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivFAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivFAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DivFOp> DivFOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FDIV) {
-    return reinterpret_cast<const DivFOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DivFOp> DivFOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DivFOp DivFOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::DivFOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DivFOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivFOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivFOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DivSAssignOp> DivSAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_SDIV) {
-    return reinterpret_cast<const DivSAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DivSAssignOp> DivSAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DivSAssignOp DivSAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::DivSAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DivSAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivSAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivSAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DivSOp> DivSOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_SDIV) {
-    return reinterpret_cast<const DivSOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DivSOp> DivSOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DivSOp DivSOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::DivSOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DivSOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivSOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivSOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DivUAssignOp> DivUAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_UDIV) {
-    return reinterpret_cast<const DivUAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DivUAssignOp> DivUAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DivUAssignOp DivUAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::DivUAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DivUAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivUAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivUAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DivUOp> DivUOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_UDIV) {
-    return reinterpret_cast<const DivUOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DivUOp> DivUOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DivUOp DivUOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::DivUOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DivUOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivUOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value DivUOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DoOp> DoOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_DO) {
-    return reinterpret_cast<const DoOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DoOp> DoOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DoOp DoOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::DoOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region DoOp::body_region(void) const {
-  auto &val = underlying_repr().getBodyRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region DoOp::condition_region(void) const {
-  auto &val = underlying_repr().getCondRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<EmptyDeclOp> EmptyDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_EMPTY_DECL) {
-    return reinterpret_cast<const EmptyDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<EmptyDeclOp> EmptyDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::EmptyDeclOp EmptyDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::EmptyDeclOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<EnumConstantOp> EnumConstantOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ENUM_CONST) {
-    return reinterpret_cast<const EnumConstantOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<EnumConstantOp> EnumConstantOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::EnumConstantOp EnumConstantOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::EnumConstantOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region EnumConstantOp::initializer(void) const {
-  auto &val = underlying_repr().getInit();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view EnumConstantOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<EnumDeclOp> EnumDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ENUM) {
-    return reinterpret_cast<const EnumDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<EnumDeclOp> EnumDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::EnumDeclOp EnumDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::EnumDeclOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region EnumDeclOp::constants(void) const {
-  auto &val = underlying_repr().getConstants();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view EnumDeclOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<::mx::ir::Type> EnumDeclOp::type(void) const {
-  auto opt_val = underlying_repr().getType();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return ::mx::ir::Type(
-      val.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          val.getAsOpaquePointer()));
-}
-
-bool EnumDeclOp::is_complete(void) const {
-  auto val = underlying_repr().isComplete();
-  return val;
-}
-
-::mx::ir::Block EnumDeclOp::constants_block(void) const {
-  auto &val = underlying_repr().getConstantsBlock();
-  return ::mx::ir::Block(module_, val);
-}
-
-std::optional<EnumRefOp> EnumRefOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ENUMREF) {
-    return reinterpret_cast<const EnumRefOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<EnumRefOp> EnumRefOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::EnumRefOp EnumRefOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::EnumRefOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value EnumRefOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::string_view EnumRefOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<ExprOp> ExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_EXPR) {
-    return reinterpret_cast<const ExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExprOp> ExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ExprOp ExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ExprOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region ExprOp::nested_expression(void) const {
-  auto &val = underlying_repr().getSubexpr();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<ExtensionOp> ExtensionOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_GNU_EXTENSION) {
-    return reinterpret_cast<const ExtensionOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExtensionOp> ExtensionOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ExtensionOp ExtensionOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ExtensionOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ExtensionOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ExtensionOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FCmpOp> FCmpOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FCMP) {
-    return reinterpret_cast<const FCmpOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FCmpOp> FCmpOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::FCmpOp FCmpOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::FCmpOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FCmpOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FCmpOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FCmpOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FieldDeclOp> FieldDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FIELD) {
-    return reinterpret_cast<const FieldDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FieldDeclOp> FieldDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::FieldDeclOp FieldDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::FieldDeclOp(this->::mx::ir::Operation::op_);
-}
-
-std::string_view FieldDeclOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type FieldDeclOp::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<unsigned int> FieldDeclOp::bits(void) const {
-  auto opt_val = underlying_repr().getBits();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<FileScopeAsmOp> FileScopeAsmOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FILE_SCOPE_ASM) {
-    return reinterpret_cast<const FileScopeAsmOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FileScopeAsmOp> FileScopeAsmOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::FileScopeAsmOp FileScopeAsmOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::FileScopeAsmOp(this->::mx::ir::Operation::op_);
-}
-
-std::string_view FileScopeAsmOp::assembly(void) const {
-  auto val = underlying_repr().getAsmString();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<ForOp> ForOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FOR) {
-    return reinterpret_cast<const ForOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ForOp> ForOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ForOp ForOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ForOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region ForOp::condition_region(void) const {
-  auto &val = underlying_repr().getCondRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<::mx::ir::Region> ForOp::incr_region(void) const {
-  decltype(auto) opt_val = underlying_repr().getIncrRegion();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<::mx::ir::Region> ForOp::body_region(void) const {
-  decltype(auto) opt_val = underlying_repr().getBodyRegion();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<FuncOp> FuncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FUNC) {
-    return reinterpret_cast<const FuncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FuncOp> FuncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::FuncOp FuncOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::FuncOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<::mx::ir::Region> FuncOp::body(void) const {
-  decltype(auto) opt_val = underlying_repr().getBody();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view FuncOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type FuncOp::function_type(void) const {
-  auto mlir_type = underlying_repr().getFunctionType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<std::string_view> FuncOp::visibility(void) const {
-  auto opt_val = underlying_repr().getSymVisibility();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool FuncOp::is_var_arg(void) const {
-  auto val = underlying_repr().isVarArg();
-  return val;
-}
-
-gap::generator<::mx::ir::Type> FuncOp::callable_results(void) const & {
-  auto range = underlying_repr().getCallableResults();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-gap::generator<::mx::ir::Type> FuncOp::argument_types(void) const & {
-  auto range = underlying_repr().getArgumentTypes();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-gap::generator<::mx::ir::Type> FuncOp::result_types(void) const & {
-  auto range = underlying_repr().getResultTypes();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-bool FuncOp::is_declaration(void) const {
-  auto val = underlying_repr().isDeclaration();
-  return val;
-}
-
-std::optional<FuncRefOp> FuncRefOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FUNCREF) {
-    return reinterpret_cast<const FuncRefOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FuncRefOp> FuncRefOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::FuncRefOp FuncRefOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::FuncRefOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FuncRefOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::string_view FuncRefOp::function(void) const {
-  auto val = underlying_repr().getFunction();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<GenericAssocExprOp> GenericAssocExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_GENERIC_ASOC) {
-    return reinterpret_cast<const GenericAssocExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GenericAssocExprOp> GenericAssocExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::GenericAssocExpr GenericAssocExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::GenericAssocExpr(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value GenericAssocExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region GenericAssocExprOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<::mx::ir::Type> GenericAssocExprOp::match_type(void) const {
-  auto opt_val = underlying_repr().getMatchType();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return ::mx::ir::Type(
-      val.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          val.getAsOpaquePointer()));
-}
-
-std::optional<GenericSelectionExprOp> GenericSelectionExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_GENERIC_EXPR) {
-    return reinterpret_cast<const GenericSelectionExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GenericSelectionExprOp> GenericSelectionExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::GenericSelectionExpr GenericSelectionExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::GenericSelectionExpr(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value GenericSelectionExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region GenericSelectionExprOp::control(void) const {
-  auto &val = underlying_repr().getControl();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region GenericSelectionExprOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<::mx::ir::Type> GenericSelectionExprOp::control_type(void) const {
-  auto opt_val = underlying_repr().getControlType();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return ::mx::ir::Type(
-      val.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          val.getAsOpaquePointer()));
-}
-
-bool GenericSelectionExprOp::is_expression_predicate(void) const {
-  auto val = underlying_repr().isExprPredicate();
-  return val;
-}
-
-bool GenericSelectionExprOp::is_type_predicate(void) const {
-  auto val = underlying_repr().isTypePredicate();
-  return val;
-}
-
-std::optional<GlobalRefOp> GlobalRefOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_GLOBREF) {
-    return reinterpret_cast<const GlobalRefOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GlobalRefOp> GlobalRefOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::GlobalRefOp GlobalRefOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::GlobalRefOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value GlobalRefOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::string_view GlobalRefOp::global(void) const {
-  auto val = underlying_repr().getGlobal();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<GotoStmtOp> GotoStmtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_GOTO) {
-    return reinterpret_cast<const GotoStmtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GotoStmtOp> GotoStmtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::GotoStmt GotoStmtOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::GotoStmt(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value GotoStmtOp::label(void) const {
-  auto val = underlying_repr().getLabel();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<IfOp> IfOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_IF) {
-    return reinterpret_cast<const IfOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<IfOp> IfOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::IfOp IfOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::IfOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region IfOp::condition_region(void) const {
-  auto &val = underlying_repr().getCondRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region IfOp::then_region(void) const {
-  auto &val = underlying_repr().getThenRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<::mx::ir::Region> IfOp::else_region(void) const {
-  decltype(auto) opt_val = underlying_repr().getElseRegion();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-bool IfOp::has_else(void) const {
-  auto val = underlying_repr().hasElse();
-  return val;
-}
-
-std::optional<ImagOp> ImagOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_IMAG) {
-    return reinterpret_cast<const ImagOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ImagOp> ImagOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ImagOp ImagOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ImagOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ImagOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ImagOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ImplicitCastOp> ImplicitCastOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_IMPLICIT_CAST) {
-    return reinterpret_cast<const ImplicitCastOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ImplicitCastOp> ImplicitCastOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ImplicitCastOp ImplicitCastOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ImplicitCastOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ImplicitCastOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ImplicitCastOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<IndirectCallOp> IndirectCallOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_INDIRECT_CALL) {
-    return reinterpret_cast<const IndirectCallOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<IndirectCallOp> IndirectCallOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::IndirectCallOp IndirectCallOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::IndirectCallOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value IndirectCallOp::callee(void) const {
-  auto val = underlying_repr().getCallee();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> IndirectCallOp::arg_operands(void) const & {
-  auto range = underlying_repr().getArgOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Result> IndirectCallOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<IndirectGotoStmtOp> IndirectGotoStmtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_INDIRECT_GOTO) {
-    return reinterpret_cast<const IndirectGotoStmtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<IndirectGotoStmtOp> IndirectGotoStmtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::IndirectGotoStmt IndirectGotoStmtOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::IndirectGotoStmt(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region IndirectGotoStmtOp::target(void) const {
-  auto &val = underlying_repr().getTarget();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<InitListExprOp> InitListExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_INITLIST) {
-    return reinterpret_cast<const InitListExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InitListExprOp> InitListExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::InitListExpr InitListExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::InitListExpr(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> InitListExprOp::elements(void) const & {
-  auto range = underlying_repr().getElements();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<InitializedConstantOp> InitializedConstantOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_CONST_INIT) {
-    return reinterpret_cast<const InitializedConstantOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InitializedConstantOp> InitializedConstantOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::InitializedConstantOp InitializedConstantOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::InitializedConstantOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value InitializedConstantOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region InitializedConstantOp::initializer(void) const {
-  auto &val = underlying_repr().getInit();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<LNotOp> LNotOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_LNOT) {
-    return reinterpret_cast<const LNotOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LNotOp> LNotOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LNotOp LNotOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::LNotOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value LNotOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value LNotOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<LabelDeclOp> LabelDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_LABEL_DECL) {
-    return reinterpret_cast<const LabelDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LabelDeclOp> LabelDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LabelDeclOp LabelDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::LabelDeclOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value LabelDeclOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::string_view LabelDeclOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<LabelStmtOp> LabelStmtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_LABEL) {
-    return reinterpret_cast<const LabelStmtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LabelStmtOp> LabelStmtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LabelStmt LabelStmtOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::LabelStmt(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value LabelStmtOp::label(void) const {
-  auto val = underlying_repr().getLabel();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region LabelStmtOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<MinusOp> MinusOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_MINUS) {
-    return reinterpret_cast<const MinusOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MinusOp> MinusOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::MinusOp MinusOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::MinusOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MinusOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MinusOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<MulFAssignOp> MulFAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_FMUL) {
-    return reinterpret_cast<const MulFAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MulFAssignOp> MulFAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::MulFAssignOp MulFAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::MulFAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MulFAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulFAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulFAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<MulFOp> MulFOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FMUL) {
-    return reinterpret_cast<const MulFOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MulFOp> MulFOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::MulFOp MulFOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::MulFOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MulFOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulFOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulFOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<MulIAssignOp> MulIAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_MUL) {
-    return reinterpret_cast<const MulIAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MulIAssignOp> MulIAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::MulIAssignOp MulIAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::MulIAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MulIAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulIAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulIAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<MulIOp> MulIOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_MUL) {
-    return reinterpret_cast<const MulIOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MulIOp> MulIOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::MulIOp MulIOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::MulIOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MulIOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulIOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulIOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<NotOp> NotOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_NOT) {
-    return reinterpret_cast<const NotOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<NotOp> NotOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::NotOp NotOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::NotOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value NotOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value NotOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<NullStmtOp> NullStmtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_NULL) {
-    return reinterpret_cast<const NullStmtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<NullStmtOp> NullStmtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::NullStmt NullStmtOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::NullStmt(this->::mx::ir::Operation::op_);
-}
-
-std::optional<OffsetOfExprOp> OffsetOfExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_OFFSETOF_EXPR) {
-    return reinterpret_cast<const OffsetOfExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<OffsetOfExprOp> OffsetOfExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::OffsetOfExprOp OffsetOfExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::OffsetOfExprOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value OffsetOfExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Region> OffsetOfExprOp::array_index_exprs(void) const & {
-  decltype(auto) regions = underlying_repr().getArrayIndexExprs();
-  for (auto &region : regions) {
-    co_yield ::mx::ir::Region(module_, &region);
-  }
-}
-
-::mx::ir::Type OffsetOfExprOp::source(void) const {
-  auto mlir_type = underlying_repr().getSource();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<OpaqueValueExprOp> OpaqueValueExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_OPAQUE_EXPR) {
-    return reinterpret_cast<const OpaqueValueExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<OpaqueValueExprOp> OpaqueValueExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::OpaqueValueExpr OpaqueValueExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::OpaqueValueExpr(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> OpaqueValueExprOp::argument(void) const & {
-  auto range = underlying_repr().getArg();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value OpaqueValueExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PlusOp> PlusOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_PLUS) {
-    return reinterpret_cast<const PlusOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PlusOp> PlusOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PlusOp PlusOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::PlusOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PlusOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value PlusOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PostDecOp> PostDecOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_POST_DEC) {
-    return reinterpret_cast<const PostDecOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PostDecOp> PostDecOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PostDecOp PostDecOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::PostDecOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PostDecOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value PostDecOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PostIncOp> PostIncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_POST_INC) {
-    return reinterpret_cast<const PostIncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PostIncOp> PostIncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PostIncOp PostIncOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::PostIncOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PostIncOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value PostIncOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PreDecOp> PreDecOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_PRE_DEC) {
-    return reinterpret_cast<const PreDecOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PreDecOp> PreDecOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PreDecOp PreDecOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::PreDecOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PreDecOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value PreDecOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PreIncOp> PreIncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_PRE_INC) {
-    return reinterpret_cast<const PreIncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PreIncOp> PreIncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PreIncOp PreIncOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::PreIncOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PreIncOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value PreIncOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PredefinedExprOp> PredefinedExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_PREDEFINED_EXPR) {
-    return reinterpret_cast<const PredefinedExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PredefinedExprOp> PredefinedExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PredefinedExpr PredefinedExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::PredefinedExpr(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PredefinedExprOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value PredefinedExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PreferredAlignOfExprOp> PreferredAlignOfExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_PREFERRED_ALIGNOF_EXPR) {
-    return reinterpret_cast<const PreferredAlignOfExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PreferredAlignOfExprOp> PreferredAlignOfExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PreferredAlignOfExprOp PreferredAlignOfExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::PreferredAlignOfExprOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PreferredAlignOfExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region PreferredAlignOfExprOp::expression(void) const {
-  auto &val = underlying_repr().getExpr();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<PreferredAlignOfTypeOp> PreferredAlignOfTypeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_PREFERRED_ALIGNOF_TYPE) {
-    return reinterpret_cast<const PreferredAlignOfTypeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PreferredAlignOfTypeOp> PreferredAlignOfTypeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PreferredAlignOfTypeOp PreferredAlignOfTypeOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::PreferredAlignOfTypeOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PreferredAlignOfTypeOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Type PreferredAlignOfTypeOp::argument(void) const {
-  auto mlir_type = underlying_repr().getArg();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<RealOp> RealOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_REAL) {
-    return reinterpret_cast<const RealOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RealOp> RealOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RealOp RealOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::RealOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RealOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RealOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RecordMemberOp> RecordMemberOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_MEMBER) {
-    return reinterpret_cast<const RecordMemberOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RecordMemberOp> RecordMemberOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RecordMemberOp RecordMemberOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::RecordMemberOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RecordMemberOp::record(void) const {
-  auto val = underlying_repr().getRecord();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RecordMemberOp::element(void) const {
-  auto val = underlying_repr().getElement();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::string_view RecordMemberOp::field(void) const {
-  auto val = underlying_repr().getField();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<RemFAssignOp> RemFAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_FREM) {
-    return reinterpret_cast<const RemFAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RemFAssignOp> RemFAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RemFAssignOp RemFAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::RemFAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RemFAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemFAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemFAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RemFOp> RemFOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FREM) {
-    return reinterpret_cast<const RemFOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RemFOp> RemFOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RemFOp RemFOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::RemFOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RemFOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemFOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemFOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RemSAssignOp> RemSAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_SREM) {
-    return reinterpret_cast<const RemSAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RemSAssignOp> RemSAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RemSAssignOp RemSAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::RemSAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RemSAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemSAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemSAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RemSOp> RemSOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_SREM) {
-    return reinterpret_cast<const RemSOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RemSOp> RemSOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RemSOp RemSOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::RemSOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RemSOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemSOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemSOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RemUAssignOp> RemUAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_UREM) {
-    return reinterpret_cast<const RemUAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RemUAssignOp> RemUAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RemUAssignOp RemUAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::RemUAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RemUAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemUAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemUAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RemUOp> RemUOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_UREM) {
-    return reinterpret_cast<const RemUOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RemUOp> RemUOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RemUOp RemUOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::RemUOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RemUOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemUOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RemUOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ReturnOp> ReturnOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_RETURN) {
-    return reinterpret_cast<const ReturnOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ReturnOp> ReturnOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ReturnOp ReturnOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ReturnOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> ReturnOp::result(void) const & {
-  auto range = underlying_repr().getResult();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<SizeOfExprOp> SizeOfExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_SIZEOF_EXPR) {
-    return reinterpret_cast<const SizeOfExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SizeOfExprOp> SizeOfExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::SizeOfExprOp SizeOfExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::SizeOfExprOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SizeOfExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region SizeOfExprOp::expression(void) const {
-  auto &val = underlying_repr().getExpr();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::size_t SizeOfExprOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return val;
-}
-
-std::optional<SizeOfTypeOp> SizeOfTypeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_SIZEOF_TYPE) {
-    return reinterpret_cast<const SizeOfTypeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SizeOfTypeOp> SizeOfTypeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::SizeOfTypeOp SizeOfTypeOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::SizeOfTypeOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SizeOfTypeOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Type SizeOfTypeOp::argument(void) const {
-  auto mlir_type = underlying_repr().getArg();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::size_t SizeOfTypeOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return val;
-}
-
-std::optional<StaticAssertDeclOp> StaticAssertDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_STATIC_ASSERT) {
-    return reinterpret_cast<const StaticAssertDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StaticAssertDeclOp> StaticAssertDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::StaticAssertDecl StaticAssertDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::StaticAssertDecl(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region StaticAssertDeclOp::assertion(void) const {
-  auto &val = underlying_repr().getAssert();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region StaticAssertDeclOp::message(void) const {
-  auto &val = underlying_repr().getMessage();
-  return ::mx::ir::Region(module_, val);
-}
-
-bool StaticAssertDeclOp::failed(void) const {
-  auto val = underlying_repr().getFailed();
-  return val;
-}
-
-std::optional<StmtExprOp> StmtExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_STMT_EXPR) {
-    return reinterpret_cast<const StmtExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StmtExprOp> StmtExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::StmtExprOp StmtExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::StmtExprOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value StmtExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region StmtExprOp::nested_statement(void) const {
-  auto &val = underlying_repr().getSubstmt();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<StructDeclOp> StructDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_STRUCT) {
-    return reinterpret_cast<const StructDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StructDeclOp> StructDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::StructDeclOp StructDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::StructDeclOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region StructDeclOp::fields(void) const {
-  auto &val = underlying_repr().getFields();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view StructDeclOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-gap::generator<::mx::ir::Type> StructDeclOp::field_types(void) const & {
-  auto range = underlying_repr().getFieldTypes();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-::mx::ir::Type StructDeclOp::defined_type(void) const {
-  auto mlir_type = underlying_repr().getDefinedType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-bool StructDeclOp::is_complete_definition(void) const {
-  auto val = underlying_repr().isCompleteDefinition();
-  return val;
-}
-
-::mx::ir::Block StructDeclOp::fields_block(void) const {
-  auto &val = underlying_repr().getFieldsBlock();
-  return ::mx::ir::Block(module_, val);
-}
-
-std::optional<SubFAssignOp> SubFAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_FSUB) {
-    return reinterpret_cast<const SubFAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SubFAssignOp> SubFAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::SubFAssignOp SubFAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::SubFAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SubFAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubFAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubFAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SubFOp> SubFOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_FSUB) {
-    return reinterpret_cast<const SubFOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SubFOp> SubFOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::SubFOp SubFOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::SubFOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SubFOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubFOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubFOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SubIAssignOp> SubIAssignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ASSIGN_SUB) {
-    return reinterpret_cast<const SubIAssignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SubIAssignOp> SubIAssignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::SubIAssignOp SubIAssignOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::SubIAssignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SubIAssignOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubIAssignOp::destination(void) const {
-  auto val = underlying_repr().getDst();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubIAssignOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SubIOp> SubIOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_SUB) {
-    return reinterpret_cast<const SubIOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SubIOp> SubIOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::SubIOp SubIOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::SubIOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SubIOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubIOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubIOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SubscriptOp> SubscriptOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_SUBSCRIPT) {
-    return reinterpret_cast<const SubscriptOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SubscriptOp> SubscriptOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::SubscriptOp SubscriptOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::SubscriptOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SubscriptOp::array(void) const {
-  auto val = underlying_repr().getArray();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubscriptOp::index(void) const {
-  auto val = underlying_repr().getIndex();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubscriptOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SwitchOp> SwitchOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_SWITCH) {
-    return reinterpret_cast<const SwitchOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SwitchOp> SwitchOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::SwitchOp SwitchOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::SwitchOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region SwitchOp::condition_region(void) const {
-  auto &val = underlying_repr().getCondRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-gap::generator<::mx::ir::Region> SwitchOp::cases(void) const & {
-  decltype(auto) regions = underlying_repr().getCases();
-  for (auto &region : regions) {
-    co_yield ::mx::ir::Region(module_, &region);
-  }
-}
-
-std::optional<ThisOp> ThisOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_THIS) {
-    return reinterpret_cast<const ThisOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ThisOp> ThisOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ThisOp ThisOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ThisOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ThisOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<TranslationUnitOp> TranslationUnitOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_TRANSLATION_UNIT) {
-    return reinterpret_cast<const TranslationUnitOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TranslationUnitOp> TranslationUnitOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TranslationUnitOp TranslationUnitOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::TranslationUnitOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region TranslationUnitOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<TypeAliasOp> TypeAliasOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_ALIAS) {
-    return reinterpret_cast<const TypeAliasOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TypeAliasOp> TypeAliasOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TypeAliasOp TypeAliasOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::TypeAliasOp(this->::mx::ir::Operation::op_);
-}
-
-std::string_view TypeAliasOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type TypeAliasOp::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<TypeDeclOp> TypeDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_TYPE) {
-    return reinterpret_cast<const TypeDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TypeDeclOp> TypeDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TypeDeclOp TypeDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::TypeDeclOp(this->::mx::ir::Operation::op_);
-}
-
-std::string_view TypeDeclOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type TypeDeclOp::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-::mx::ir::Type TypeDeclOp::defined_type(void) const {
-  auto mlir_type = underlying_repr().getDefinedType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<TypeDefOp> TypeDefOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_TYPEDEF) {
-    return reinterpret_cast<const TypeDefOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TypeDefOp> TypeDefOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TypeDefOp TypeDefOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::TypeDefOp(this->::mx::ir::Operation::op_);
-}
-
-std::string_view TypeDefOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type TypeDefOp::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-::mx::ir::Type TypeDefOp::defined_type(void) const {
-  auto mlir_type = underlying_repr().getDefinedType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<TypeOfExprOp> TypeOfExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_TYPEOF_EXPR) {
-    return reinterpret_cast<const TypeOfExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TypeOfExprOp> TypeOfExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TypeOfExprOp TypeOfExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::TypeOfExprOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region TypeOfExprOp::expression(void) const {
-  auto &val = underlying_repr().getExpr();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view TypeOfExprOp::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type TypeOfExprOp::type(void) const {
-  auto mlir_type = underlying_repr().getType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<TypeYieldOp> TypeYieldOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_TYPE_YIELD) {
-    return reinterpret_cast<const TypeYieldOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TypeYieldOp> TypeYieldOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TypeYieldOp TypeYieldOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::TypeYieldOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value TypeYieldOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Type TypeYieldOp::yielded(void) const {
-  auto mlir_type = underlying_repr().getYielded();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<UnionDeclOp> UnionDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_UNION) {
-    return reinterpret_cast<const UnionDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UnionDeclOp> UnionDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::UnionDeclOp UnionDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::UnionDeclOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region UnionDeclOp::fields(void) const {
-  auto &val = underlying_repr().getFields();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view UnionDeclOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-gap::generator<::mx::ir::Type> UnionDeclOp::field_types(void) const & {
-  auto range = underlying_repr().getFieldTypes();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-::mx::ir::Type UnionDeclOp::defined_type(void) const {
-  auto mlir_type = underlying_repr().getDefinedType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-bool UnionDeclOp::is_complete_definition(void) const {
-  auto val = underlying_repr().isCompleteDefinition();
-  return val;
-}
-
-::mx::ir::Block UnionDeclOp::fields_block(void) const {
-  auto &val = underlying_repr().getFieldsBlock();
-  return ::mx::ir::Block(module_, val);
-}
-
-std::optional<UnreachableOp> UnreachableOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_UNREACHABLE) {
-    return reinterpret_cast<const UnreachableOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UnreachableOp> UnreachableOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::UnreachableOp UnreachableOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::UnreachableOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<VAArgExprOp> VAArgExprOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_VA_ARG_EXPR) {
-    return reinterpret_cast<const VAArgExprOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VAArgExprOp> VAArgExprOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::VAArgExpr VAArgExprOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::VAArgExpr(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VAArgExprOp::argument_list(void) const {
-  auto val = underlying_repr().getArgList();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VAArgExprOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ValueYieldOp> ValueYieldOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_VALUE_YIELD) {
-    return reinterpret_cast<const ValueYieldOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ValueYieldOp> ValueYieldOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ValueYieldOp ValueYieldOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::ValueYieldOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ValueYieldOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VarDeclOp> VarDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_VAR) {
-    return reinterpret_cast<const VarDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VarDeclOp> VarDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::VarDeclOp VarDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::VarDeclOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VarDeclOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<::mx::ir::Region> VarDeclOp::initializer(void) const {
-  decltype(auto) opt_val = underlying_repr().getInitializer();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<::mx::ir::Region> VarDeclOp::allocation_size(void) const {
-  decltype(auto) opt_val = underlying_repr().getAllocationSize();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view VarDeclOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool VarDeclOp::has_local_storage(void) const {
-  auto val = underlying_repr().hasLocalStorage();
-  return val;
-}
-
-bool VarDeclOp::is_local_variable_declaration(void) const {
-  auto val = underlying_repr().isLocalVarDecl();
-  return val;
-}
-
-bool VarDeclOp::is_static_local_variable_declaration(void) const {
-  auto val = underlying_repr().isStaticLocal();
-  return val;
-}
-
-bool VarDeclOp::has_external_storage(void) const {
-  auto val = underlying_repr().hasExternalStorage();
-  return val;
-}
-
-bool VarDeclOp::has_global_storage(void) const {
-  auto val = underlying_repr().hasGlobalStorage();
-  return val;
-}
-
-bool VarDeclOp::is_static_data_member(void) const {
-  auto val = underlying_repr().isStaticDataMember();
-  return val;
-}
-
-bool VarDeclOp::is_in_file_context(void) const {
-  auto val = underlying_repr().isInFileContext();
-  return val;
-}
-
-bool VarDeclOp::is_in_function_or_method_context(void) const {
-  auto val = underlying_repr().isInFunctionOrMethodContext();
-  return val;
-}
-
-bool VarDeclOp::is_in_record_context(void) const {
-  auto val = underlying_repr().isInRecordContext();
-  return val;
-}
-
-bool VarDeclOp::is_file_variable_declaration(void) const {
-  auto val = underlying_repr().isFileVarDecl();
-  return val;
-}
-
-std::optional<WhileOp> WhileOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::HL_WHILE) {
-    return reinterpret_cast<const WhileOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<WhileOp> WhileOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::hl::WhileOp WhileOp::underlying_repr(void) const noexcept {
-  return ::vast::hl::WhileOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region WhileOp::condition_region(void) const {
-  auto &val = underlying_repr().getCondRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Region WhileOp::body_region(void) const {
-  auto &val = underlying_repr().getBodyRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-}  // namespace mx::ir::hl
diff --git a/lib/IR/HighLevel/Type.cpp b/lib/IR/HighLevel/Type.cpp
deleted file mode 100644
index 3fcc3f8c1..000000000
--- a/lib/IR/HighLevel/Type.cpp
+++ /dev/null
@@ -1,434 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/HighLevel/Type.h>
-
-#include <multiplier/IR/Attribute.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <vast/Dialect/ABI/ABIOps.hpp>
-#include <vast/Dialect/HighLevel/HighLevelOps.hpp>
-
-namespace mx::ir::hl {
-std::optional<Type> Type::from(const ::mx::ir::Type &that) {
-  if (IsHighLevelTypeKind(that.kind())) {
-    return reinterpret_cast<const Type &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RecordType> RecordType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_RECORD) {
-    return reinterpret_cast<const RecordType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RecordType RecordType::underlying_repr(void) const noexcept {
-  return ::vast::hl::RecordType(this->::mx::ir::Type::type_);
-}
-
-std::string_view RecordType::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<EnumType> EnumType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_ENUM) {
-    return reinterpret_cast<const EnumType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::EnumType EnumType::underlying_repr(void) const noexcept {
-  return ::vast::hl::EnumType(this->::mx::ir::Type::type_);
-}
-
-std::string_view EnumType::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<TypedefType> TypedefType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_TYPEDEF) {
-    return reinterpret_cast<const TypedefType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TypedefType TypedefType::underlying_repr(void) const noexcept {
-  return ::vast::hl::TypedefType(this->::mx::ir::Type::type_);
-}
-
-std::string_view TypedefType::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<ElaboratedType> ElaboratedType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_ELABORATED) {
-    return reinterpret_cast<const ElaboratedType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ElaboratedType ElaboratedType::underlying_repr(void) const noexcept {
-  return ::vast::hl::ElaboratedType(this->::mx::ir::Type::type_);
-}
-
-std::optional<LabelType> LabelType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_LABEL) {
-    return reinterpret_cast<const LabelType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LabelType LabelType::underlying_repr(void) const noexcept {
-  return ::vast::hl::LabelType(this->::mx::ir::Type::type_);
-}
-
-std::optional<ParenType> ParenType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_PAREN) {
-    return reinterpret_cast<const ParenType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ParenType ParenType::underlying_repr(void) const noexcept {
-  return ::vast::hl::ParenType(this->::mx::ir::Type::type_);
-}
-
-std::optional<LValueType> LValueType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_L_VALUE) {
-    return reinterpret_cast<const LValueType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LValueType LValueType::underlying_repr(void) const noexcept {
-  return ::vast::hl::LValueType(this->::mx::ir::Type::type_);
-}
-
-std::optional<RValueType> RValueType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_R_VALUE) {
-    return reinterpret_cast<const RValueType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::RValueType RValueType::underlying_repr(void) const noexcept {
-  return ::vast::hl::RValueType(this->::mx::ir::Type::type_);
-}
-
-std::optional<VoidType> VoidType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_VOID) {
-    return reinterpret_cast<const VoidType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::VoidType VoidType::underlying_repr(void) const noexcept {
-  return ::vast::hl::VoidType(this->::mx::ir::Type::type_);
-}
-
-std::optional<BoolType> BoolType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_BOOL) {
-    return reinterpret_cast<const BoolType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BoolType BoolType::underlying_repr(void) const noexcept {
-  return ::vast::hl::BoolType(this->::mx::ir::Type::type_);
-}
-
-std::optional<CharType> CharType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_CHAR) {
-    return reinterpret_cast<const CharType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::CharType CharType::underlying_repr(void) const noexcept {
-  return ::vast::hl::CharType(this->::mx::ir::Type::type_);
-}
-
-std::optional<ShortType> ShortType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_SHORT) {
-    return reinterpret_cast<const ShortType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ShortType ShortType::underlying_repr(void) const noexcept {
-  return ::vast::hl::ShortType(this->::mx::ir::Type::type_);
-}
-
-std::optional<IntType> IntType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_INT) {
-    return reinterpret_cast<const IntType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::IntType IntType::underlying_repr(void) const noexcept {
-  return ::vast::hl::IntType(this->::mx::ir::Type::type_);
-}
-
-std::optional<LongType> LongType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_LONG) {
-    return reinterpret_cast<const LongType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LongType LongType::underlying_repr(void) const noexcept {
-  return ::vast::hl::LongType(this->::mx::ir::Type::type_);
-}
-
-std::optional<LongLongType> LongLongType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_LONG_LONG) {
-    return reinterpret_cast<const LongLongType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LongLongType LongLongType::underlying_repr(void) const noexcept {
-  return ::vast::hl::LongLongType(this->::mx::ir::Type::type_);
-}
-
-std::optional<Int128Type> Int128Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_INT128) {
-    return reinterpret_cast<const Int128Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::Int128Type Int128Type::underlying_repr(void) const noexcept {
-  return ::vast::hl::Int128Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<HalfType> HalfType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_HALF) {
-    return reinterpret_cast<const HalfType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::HalfType HalfType::underlying_repr(void) const noexcept {
-  return ::vast::hl::HalfType(this->::mx::ir::Type::type_);
-}
-
-std::optional<BFloat16Type> BFloat16Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_B_FLOAT16) {
-    return reinterpret_cast<const BFloat16Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::BFloat16Type BFloat16Type::underlying_repr(void) const noexcept {
-  return ::vast::hl::BFloat16Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<FloatType> FloatType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_FLOAT) {
-    return reinterpret_cast<const FloatType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::FloatType FloatType::underlying_repr(void) const noexcept {
-  return ::vast::hl::FloatType(this->::mx::ir::Type::type_);
-}
-
-std::optional<DoubleType> DoubleType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_DOUBLE) {
-    return reinterpret_cast<const DoubleType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DoubleType DoubleType::underlying_repr(void) const noexcept {
-  return ::vast::hl::DoubleType(this->::mx::ir::Type::type_);
-}
-
-std::optional<LongDoubleType> LongDoubleType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_LONG_DOUBLE) {
-    return reinterpret_cast<const LongDoubleType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::LongDoubleType LongDoubleType::underlying_repr(void) const noexcept {
-  return ::vast::hl::LongDoubleType(this->::mx::ir::Type::type_);
-}
-
-std::optional<Float128Type> Float128Type::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_FLOAT128) {
-    return reinterpret_cast<const Float128Type &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::Float128Type Float128Type::underlying_repr(void) const noexcept {
-  return ::vast::hl::Float128Type(this->::mx::ir::Type::type_);
-}
-
-std::optional<ComplexType> ComplexType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_COMPLEX) {
-    return reinterpret_cast<const ComplexType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ComplexType ComplexType::underlying_repr(void) const noexcept {
-  return ::vast::hl::ComplexType(this->::mx::ir::Type::type_);
-}
-
-std::optional<PointerType> PointerType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_POINTER) {
-    return reinterpret_cast<const PointerType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::PointerType PointerType::underlying_repr(void) const noexcept {
-  return ::vast::hl::PointerType(this->::mx::ir::Type::type_);
-}
-
-std::optional<ArrayType> ArrayType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_ARRAY) {
-    return reinterpret_cast<const ArrayType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ArrayType ArrayType::underlying_repr(void) const noexcept {
-  return ::vast::hl::ArrayType(this->::mx::ir::Type::type_);
-}
-
-std::optional<VectorType> VectorType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_VECTOR) {
-    return reinterpret_cast<const VectorType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::VectorType VectorType::underlying_repr(void) const noexcept {
-  return ::vast::hl::VectorType(this->::mx::ir::Type::type_);
-}
-
-std::optional<DecayedType> DecayedType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_DECAYED) {
-    return reinterpret_cast<const DecayedType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::DecayedType DecayedType::underlying_repr(void) const noexcept {
-  return ::vast::hl::DecayedType(this->::mx::ir::Type::type_);
-}
-
-std::optional<AttributedType> AttributedType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_ATTRIBUTED) {
-    return reinterpret_cast<const AttributedType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AttributedType AttributedType::underlying_repr(void) const noexcept {
-  return ::vast::hl::AttributedType(this->::mx::ir::Type::type_);
-}
-
-std::optional<AdjustedType> AdjustedType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_ADJUSTED) {
-    return reinterpret_cast<const AdjustedType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AdjustedType AdjustedType::underlying_repr(void) const noexcept {
-  return ::vast::hl::AdjustedType(this->::mx::ir::Type::type_);
-}
-
-std::optional<ReferenceType> ReferenceType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_REFERENCE) {
-    return reinterpret_cast<const ReferenceType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::ReferenceType ReferenceType::underlying_repr(void) const noexcept {
-  return ::vast::hl::ReferenceType(this->::mx::ir::Type::type_);
-}
-
-std::optional<TypeOfExprType> TypeOfExprType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_TYPE_OF_EXPR) {
-    return reinterpret_cast<const TypeOfExprType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TypeOfExprType TypeOfExprType::underlying_repr(void) const noexcept {
-  return ::vast::hl::TypeOfExprType(this->::mx::ir::Type::type_);
-}
-
-std::string_view TypeOfExprType::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<TypeOfTypeType> TypeOfTypeType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_TYPE_OF_TYPE) {
-    return reinterpret_cast<const TypeOfTypeType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::TypeOfTypeType TypeOfTypeType::underlying_repr(void) const noexcept {
-  return ::vast::hl::TypeOfTypeType(this->::mx::ir::Type::type_);
-}
-
-std::optional<AutoType> AutoType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_AUTO) {
-    return reinterpret_cast<const AutoType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AutoType AutoType::underlying_repr(void) const noexcept {
-  return ::vast::hl::AutoType(this->::mx::ir::Type::type_);
-}
-
-std::optional<AtomicType> AtomicType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::HL_ATOMIC) {
-    return reinterpret_cast<const AtomicType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::hl::AtomicType AtomicType::underlying_repr(void) const noexcept {
-  return ::vast::hl::AtomicType(this->::mx::ir::Type::type_);
-}
-
-}  // namespace mx::ir::hl
diff --git a/lib/IR/LLVM/Attribute.cpp b/lib/IR/LLVM/Attribute.cpp
deleted file mode 100644
index 7c288e163..000000000
--- a/lib/IR/LLVM/Attribute.cpp
+++ /dev/null
@@ -1,711 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Attribute.h>
-
-#include <multiplier/IR/Type.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-
-namespace mx::ir::llvm {
-std::optional<Attribute> Attribute::from(const ::mx::ir::Attribute &that) {
-  if (IsLLVMIRAttributeKind(that.kind())) {
-    return reinterpret_cast<const Attribute &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CConvAttr> CConvAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_C_CONV) {
-    return reinterpret_cast<const CConvAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CConvAttr CConvAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CConvAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<ComdatAttr> ComdatAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_COMDAT) {
-    return reinterpret_cast<const ComdatAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ComdatAttr ComdatAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ComdatAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LinkageAttr> LinkageAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LINKAGE) {
-    return reinterpret_cast<const LinkageAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LinkageAttr LinkageAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LinkageAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<FramePointerKindAttr> FramePointerKindAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_FRAME_POINTER_KIND) {
-    return reinterpret_cast<const FramePointerKindAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FramePointerKindAttr FramePointerKindAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FramePointerKindAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopVectorizeAttr> LoopVectorizeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_VECTORIZE) {
-    return reinterpret_cast<const LoopVectorizeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopVectorizeAttr LoopVectorizeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopVectorizeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopInterleaveAttr> LoopInterleaveAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_INTERLEAVE) {
-    return reinterpret_cast<const LoopInterleaveAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopInterleaveAttr LoopInterleaveAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopInterleaveAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopUnrollAttr> LoopUnrollAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_UNROLL) {
-    return reinterpret_cast<const LoopUnrollAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopUnrollAttr LoopUnrollAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopUnrollAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopUnrollAndJamAttr> LoopUnrollAndJamAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_UNROLL_AND_JAM) {
-    return reinterpret_cast<const LoopUnrollAndJamAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopUnrollAndJamAttr LoopUnrollAndJamAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopUnrollAndJamAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopLICMAttr> LoopLICMAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_LICM) {
-    return reinterpret_cast<const LoopLICMAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopLICMAttr LoopLICMAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopLICMAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopDistributeAttr> LoopDistributeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_DISTRIBUTE) {
-    return reinterpret_cast<const LoopDistributeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopDistributeAttr LoopDistributeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopDistributeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopPipelineAttr> LoopPipelineAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_PIPELINE) {
-    return reinterpret_cast<const LoopPipelineAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopPipelineAttr LoopPipelineAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopPipelineAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopPeeledAttr> LoopPeeledAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_PEELED) {
-    return reinterpret_cast<const LoopPeeledAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopPeeledAttr LoopPeeledAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopPeeledAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopUnswitchAttr> LoopUnswitchAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_UNSWITCH) {
-    return reinterpret_cast<const LoopUnswitchAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopUnswitchAttr LoopUnswitchAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopUnswitchAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<LoopAnnotationAttr> LoopAnnotationAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_LOOP_ANNOTATION) {
-    return reinterpret_cast<const LoopAnnotationAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoopAnnotationAttr LoopAnnotationAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoopAnnotationAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DIExpressionElemAttr> DIExpressionElemAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_EXPRESSION_ELEM) {
-    return reinterpret_cast<const DIExpressionElemAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DIExpressionElemAttr DIExpressionElemAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DIExpressionElemAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DIExpressionElemAttr::opcode(void) const {
-  auto val = underlying_repr().getOpcode();
-  return val;
-}
-
-std::optional<DIExpressionAttr> DIExpressionAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_EXPRESSION) {
-    return reinterpret_cast<const DIExpressionAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DIExpressionAttr DIExpressionAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DIExpressionAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DINullTypeAttr> DINullTypeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_NULL_TYPE) {
-    return reinterpret_cast<const DINullTypeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DINullTypeAttr DINullTypeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DINullTypeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DIBasicTypeAttr> DIBasicTypeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_BASIC_TYPE) {
-    return reinterpret_cast<const DIBasicTypeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DIBasicTypeAttr DIBasicTypeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DIBasicTypeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DIBasicTypeAttr::tag(void) const {
-  auto val = underlying_repr().getTag();
-  return val;
-}
-
-uint64_t DIBasicTypeAttr::size_in_bits(void) const {
-  auto val = underlying_repr().getSizeInBits();
-  return val;
-}
-
-unsigned int DIBasicTypeAttr::encoding(void) const {
-  auto val = underlying_repr().getEncoding();
-  return val;
-}
-
-std::optional<DICompileUnitAttr> DICompileUnitAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_COMPILE_UNIT) {
-    return reinterpret_cast<const DICompileUnitAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DICompileUnitAttr DICompileUnitAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DICompileUnitAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DICompileUnitAttr::source_language(void) const {
-  auto val = underlying_repr().getSourceLanguage();
-  return val;
-}
-
-bool DICompileUnitAttr::is_optimized(void) const {
-  auto val = underlying_repr().getIsOptimized();
-  return val;
-}
-
-std::optional<DICompositeTypeAttr> DICompositeTypeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_COMPOSITE_TYPE) {
-    return reinterpret_cast<const DICompositeTypeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DICompositeTypeAttr DICompositeTypeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DICompositeTypeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DICompositeTypeAttr::tag(void) const {
-  auto val = underlying_repr().getTag();
-  return val;
-}
-
-uint32_t DICompositeTypeAttr::line(void) const {
-  auto val = underlying_repr().getLine();
-  return val;
-}
-
-uint64_t DICompositeTypeAttr::size_in_bits(void) const {
-  auto val = underlying_repr().getSizeInBits();
-  return val;
-}
-
-uint64_t DICompositeTypeAttr::align_in_bits(void) const {
-  auto val = underlying_repr().getAlignInBits();
-  return val;
-}
-
-std::optional<DIDerivedTypeAttr> DIDerivedTypeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_DERIVED_TYPE) {
-    return reinterpret_cast<const DIDerivedTypeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DIDerivedTypeAttr DIDerivedTypeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DIDerivedTypeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DIDerivedTypeAttr::tag(void) const {
-  auto val = underlying_repr().getTag();
-  return val;
-}
-
-uint64_t DIDerivedTypeAttr::size_in_bits(void) const {
-  auto val = underlying_repr().getSizeInBits();
-  return val;
-}
-
-uint32_t DIDerivedTypeAttr::align_in_bits(void) const {
-  auto val = underlying_repr().getAlignInBits();
-  return val;
-}
-
-uint64_t DIDerivedTypeAttr::offset_in_bits(void) const {
-  auto val = underlying_repr().getOffsetInBits();
-  return val;
-}
-
-std::optional<DIFileAttr> DIFileAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_FILE) {
-    return reinterpret_cast<const DIFileAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DIFileAttr DIFileAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DIFileAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DIGlobalVariableExpressionAttr> DIGlobalVariableExpressionAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_GLOBAL_VARIABLE_EXPRESSION) {
-    return reinterpret_cast<const DIGlobalVariableExpressionAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DIGlobalVariableExpressionAttr DIGlobalVariableExpressionAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DIGlobalVariableExpressionAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DIGlobalVariableAttr> DIGlobalVariableAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_GLOBAL_VARIABLE) {
-    return reinterpret_cast<const DIGlobalVariableAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DIGlobalVariableAttr DIGlobalVariableAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DIGlobalVariableAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DIGlobalVariableAttr::line(void) const {
-  auto val = underlying_repr().getLine();
-  return val;
-}
-
-bool DIGlobalVariableAttr::is_local_to_unit(void) const {
-  auto val = underlying_repr().getIsLocalToUnit();
-  return val;
-}
-
-bool DIGlobalVariableAttr::is_defined(void) const {
-  auto val = underlying_repr().getIsDefined();
-  return val;
-}
-
-unsigned int DIGlobalVariableAttr::align_in_bits(void) const {
-  auto val = underlying_repr().getAlignInBits();
-  return val;
-}
-
-std::optional<DILexicalBlockAttr> DILexicalBlockAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_LEXICAL_BLOCK) {
-    return reinterpret_cast<const DILexicalBlockAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DILexicalBlockAttr DILexicalBlockAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DILexicalBlockAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DILexicalBlockAttr::line(void) const {
-  auto val = underlying_repr().getLine();
-  return val;
-}
-
-unsigned int DILexicalBlockAttr::column(void) const {
-  auto val = underlying_repr().getColumn();
-  return val;
-}
-
-std::optional<DILexicalBlockFileAttr> DILexicalBlockFileAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_LEXICAL_BLOCK_FILE) {
-    return reinterpret_cast<const DILexicalBlockFileAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DILexicalBlockFileAttr DILexicalBlockFileAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DILexicalBlockFileAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DILexicalBlockFileAttr::discriminator(void) const {
-  auto val = underlying_repr().getDiscriminator();
-  return val;
-}
-
-std::optional<DILocalVariableAttr> DILocalVariableAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_LOCAL_VARIABLE) {
-    return reinterpret_cast<const DILocalVariableAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DILocalVariableAttr DILocalVariableAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DILocalVariableAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DILocalVariableAttr::line(void) const {
-  auto val = underlying_repr().getLine();
-  return val;
-}
-
-unsigned int DILocalVariableAttr::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return val;
-}
-
-unsigned int DILocalVariableAttr::align_in_bits(void) const {
-  auto val = underlying_repr().getAlignInBits();
-  return val;
-}
-
-std::optional<DISubprogramAttr> DISubprogramAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_SUBPROGRAM) {
-    return reinterpret_cast<const DISubprogramAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DISubprogramAttr DISubprogramAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DISubprogramAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DISubprogramAttr::line(void) const {
-  auto val = underlying_repr().getLine();
-  return val;
-}
-
-unsigned int DISubprogramAttr::scope_line(void) const {
-  auto val = underlying_repr().getScopeLine();
-  return val;
-}
-
-std::optional<DIModuleAttr> DIModuleAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_MODULE) {
-    return reinterpret_cast<const DIModuleAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DIModuleAttr DIModuleAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DIModuleAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DIModuleAttr::line(void) const {
-  auto val = underlying_repr().getLine();
-  return val;
-}
-
-bool DIModuleAttr::is_decl(void) const {
-  auto val = underlying_repr().getIsDecl();
-  return val;
-}
-
-std::optional<DINamespaceAttr> DINamespaceAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_NAMESPACE) {
-    return reinterpret_cast<const DINamespaceAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DINamespaceAttr DINamespaceAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DINamespaceAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool DINamespaceAttr::export_symbols(void) const {
-  auto val = underlying_repr().getExportSymbols();
-  return val;
-}
-
-std::optional<DISubrangeAttr> DISubrangeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_SUBRANGE) {
-    return reinterpret_cast<const DISubrangeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DISubrangeAttr DISubrangeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DISubrangeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<DISubroutineTypeAttr> DISubroutineTypeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_SUBROUTINE_TYPE) {
-    return reinterpret_cast<const DISubroutineTypeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DISubroutineTypeAttr DISubroutineTypeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DISubroutineTypeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DISubroutineTypeAttr::calling_convention(void) const {
-  auto val = underlying_repr().getCallingConvention();
-  return val;
-}
-
-std::optional<DILabelAttr> DILabelAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_DI_LABEL) {
-    return reinterpret_cast<const DILabelAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DILabelAttr DILabelAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DILabelAttr(this->::mx::ir::Attribute::attr_);
-}
-
-unsigned int DILabelAttr::line(void) const {
-  auto val = underlying_repr().getLine();
-  return val;
-}
-
-std::optional<MemoryEffectsAttr> MemoryEffectsAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_MEMORY_EFFECTS) {
-    return reinterpret_cast<const MemoryEffectsAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MemoryEffectsAttr MemoryEffectsAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MemoryEffectsAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool MemoryEffectsAttr::is_read_write(void) const {
-  auto val = underlying_repr().isReadWrite();
-  return val;
-}
-
-std::optional<AliasScopeDomainAttr> AliasScopeDomainAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_ALIAS_SCOPE_DOMAIN) {
-    return reinterpret_cast<const AliasScopeDomainAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AliasScopeDomainAttr AliasScopeDomainAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AliasScopeDomainAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<AliasScopeAttr> AliasScopeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_ALIAS_SCOPE) {
-    return reinterpret_cast<const AliasScopeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AliasScopeAttr AliasScopeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AliasScopeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<AccessGroupAttr> AccessGroupAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_ACCESS_GROUP) {
-    return reinterpret_cast<const AccessGroupAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AccessGroupAttr AccessGroupAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AccessGroupAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<TBAARootAttr> TBAARootAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_TBAA_ROOT) {
-    return reinterpret_cast<const TBAARootAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::TBAARootAttr TBAARootAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::TBAARootAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<TBAAMemberAttr> TBAAMemberAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_TBAA_MEMBER) {
-    return reinterpret_cast<const TBAAMemberAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::TBAAMemberAttr TBAAMemberAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::TBAAMemberAttr(this->::mx::ir::Attribute::attr_);
-}
-
-int64_t TBAAMemberAttr::offset(void) const {
-  auto val = underlying_repr().getOffset();
-  return val;
-}
-
-std::optional<TBAATypeDescriptorAttr> TBAATypeDescriptorAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_TBAA_TYPE_DESCRIPTOR) {
-    return reinterpret_cast<const TBAATypeDescriptorAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::TBAATypeDescriptorAttr TBAATypeDescriptorAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::TBAATypeDescriptorAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::string_view TBAATypeDescriptorAttr::id(void) const {
-  auto val = underlying_repr().getId();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<TBAATagAttr> TBAATagAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_TBAA_TAG) {
-    return reinterpret_cast<const TBAATagAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::TBAATagAttr TBAATagAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::TBAATagAttr(this->::mx::ir::Attribute::attr_);
-}
-
-int64_t TBAATagAttr::offset(void) const {
-  auto val = underlying_repr().getOffset();
-  return val;
-}
-
-bool TBAATagAttr::constant(void) const {
-  auto val = underlying_repr().getConstant();
-  return val;
-}
-
-std::optional<VScaleRangeAttr> VScaleRangeAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_V_SCALE_RANGE) {
-    return reinterpret_cast<const VScaleRangeAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VScaleRangeAttr VScaleRangeAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VScaleRangeAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<TargetFeaturesAttr> TargetFeaturesAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_TARGET_FEATURES) {
-    return reinterpret_cast<const TargetFeaturesAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::TargetFeaturesAttr TargetFeaturesAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::TargetFeaturesAttr(this->::mx::ir::Attribute::attr_);
-}
-
-bool TargetFeaturesAttr::null_or_empty(void) const {
-  auto val = underlying_repr().nullOrEmpty();
-  return val;
-}
-
-std::string TargetFeaturesAttr::features_string(void) const {
-  auto val = underlying_repr().getFeaturesString();
-  return val;
-}
-
-std::optional<IntegerOverflowFlagsAttr> IntegerOverflowFlagsAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_INTEGER_OVERFLOW_FLAGS) {
-    return reinterpret_cast<const IntegerOverflowFlagsAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::IntegerOverflowFlagsAttr IntegerOverflowFlagsAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::IntegerOverflowFlagsAttr(this->::mx::ir::Attribute::attr_);
-}
-
-std::optional<FastmathFlagsAttr> FastmathFlagsAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::LLVM_FASTMATH_FLAGS) {
-    return reinterpret_cast<const FastmathFlagsAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FastmathFlagsAttr FastmathFlagsAttr::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FastmathFlagsAttr(this->::mx::ir::Attribute::attr_);
-}
-
-}  // namespace mx::ir::llvm
diff --git a/lib/IR/LLVM/Operation.cpp b/lib/IR/LLVM/Operation.cpp
deleted file mode 100644
index 6d2e4b1be..000000000
--- a/lib/IR/LLVM/Operation.cpp
+++ /dev/null
@@ -1,7802 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Operation.h>
-
-#include <multiplier/IR/Attribute.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Type.h>
-
-#include <ios>
-#include <string>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-
-namespace mx::ir::llvm {
-std::optional<Operation> Operation::from(const ::mx::ir::Operation &that) {
-  if (IsLLVMIROperationKind(that.kind())) {
-    return reinterpret_cast<const Operation &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AShrOp> AShrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_ASHR) {
-    return reinterpret_cast<const AShrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AShrOp> AShrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AShrOp AShrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AShrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AShrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AShrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AShrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AddOp> AddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_ADD) {
-    return reinterpret_cast<const AddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AddOp> AddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AddOp AddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AddOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AddOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AddrSpaceCastOp> AddrSpaceCastOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_ADDRSPACECAST) {
-    return reinterpret_cast<const AddrSpaceCastOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AddrSpaceCastOp> AddrSpaceCastOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AddrSpaceCastOp AddrSpaceCastOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AddrSpaceCastOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AddrSpaceCastOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AddrSpaceCastOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AddressOfOp> AddressOfOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MLIR_ADDRESSOF) {
-    return reinterpret_cast<const AddressOfOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AddressOfOp> AddressOfOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AddressOfOp AddressOfOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AddressOfOp(this->::mx::ir::Operation::op_);
-}
-
-std::string_view AddressOfOp::global_name(void) const {
-  auto val = underlying_repr().getGlobalName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<AllocaOp> AllocaOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_ALLOCA) {
-    return reinterpret_cast<const AllocaOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AllocaOp> AllocaOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AllocaOp AllocaOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AllocaOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<unsigned long long> AllocaOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-::mx::ir::Type AllocaOp::elem_type(void) const {
-  auto mlir_type = underlying_repr().getElemType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-bool AllocaOp::inalloca(void) const {
-  auto val = underlying_repr().getInalloca();
-  return val;
-}
-
-std::optional<AndOp> AndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_AND) {
-    return reinterpret_cast<const AndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AndOp> AndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AndOp AndOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AndOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AndOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AndOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AndOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AtomicCmpXchgOp> AtomicCmpXchgOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_CMPXCHG) {
-    return reinterpret_cast<const AtomicCmpXchgOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AtomicCmpXchgOp> AtomicCmpXchgOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AtomicCmpXchgOp AtomicCmpXchgOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AtomicCmpXchgOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AtomicCmpXchgOp::cmp(void) const {
-  auto val = underlying_repr().getCmp();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AtomicCmpXchgOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AtomicCmpXchgOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<std::string_view> AtomicCmpXchgOp::syncscope(void) const {
-  auto opt_val = underlying_repr().getSyncscope();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<unsigned long long> AtomicCmpXchgOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-bool AtomicCmpXchgOp::weak(void) const {
-  auto val = underlying_repr().getWeak();
-  return val;
-}
-
-bool AtomicCmpXchgOp::volatile__(void) const {
-  auto val = underlying_repr().getVolatile_();
-  return val;
-}
-
-std::optional<AtomicRMWOp> AtomicRMWOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_ATOMICRMW) {
-    return reinterpret_cast<const AtomicRMWOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AtomicRMWOp> AtomicRMWOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AtomicRMWOp AtomicRMWOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AtomicRMWOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AtomicRMWOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AtomicRMWOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<std::string_view> AtomicRMWOp::syncscope(void) const {
-  auto opt_val = underlying_repr().getSyncscope();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<unsigned long long> AtomicRMWOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-bool AtomicRMWOp::volatile__(void) const {
-  auto val = underlying_repr().getVolatile_();
-  return val;
-}
-
-std::optional<BitcastOp> BitcastOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_BITCAST) {
-    return reinterpret_cast<const BitcastOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BitcastOp> BitcastOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::BitcastOp BitcastOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::BitcastOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BitcastOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BitcastOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BrOp> BrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_BR) {
-    return reinterpret_cast<const BrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BrOp> BrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::BrOp BrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::BrOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> BrOp::dest_operands(void) const & {
-  auto range = underlying_repr().getDestOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<CallIntrinsicOp> CallIntrinsicOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_CALL_INTRINSIC) {
-    return reinterpret_cast<const CallIntrinsicOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CallIntrinsicOp> CallIntrinsicOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CallIntrinsicOp CallIntrinsicOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CallIntrinsicOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> CallIntrinsicOp::arguments(void) const & {
-  auto range = underlying_repr().getArgs();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value CallIntrinsicOp::results(void) const {
-  auto val = underlying_repr().getResults();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::string_view CallIntrinsicOp::intrin(void) const {
-  auto val = underlying_repr().getIntrin();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<CallOp> CallOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_CALL) {
-    return reinterpret_cast<const CallOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CallOp> CallOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CallOp CallOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CallOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> CallOp::callee_operands(void) const & {
-  auto range = underlying_repr().getCalleeOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value CallOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<std::string_view> CallOp::callee(void) const {
-  auto opt_val = underlying_repr().getCallee();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-gap::generator<::mx::ir::Operand> CallOp::arg_operands(void) const & {
-  auto range = underlying_repr().getArgOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<ComdatOp> ComdatOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_COMDAT) {
-    return reinterpret_cast<const ComdatOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ComdatOp> ComdatOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ComdatOp ComdatOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ComdatOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region ComdatOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view ComdatOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<ComdatSelectorOp> ComdatSelectorOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_COMDAT_SELECTOR) {
-    return reinterpret_cast<const ComdatSelectorOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ComdatSelectorOp> ComdatSelectorOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ComdatSelectorOp ComdatSelectorOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ComdatSelectorOp(this->::mx::ir::Operation::op_);
-}
-
-std::string_view ComdatSelectorOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<CondBrOp> CondBrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_COND_BR) {
-    return reinterpret_cast<const CondBrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CondBrOp> CondBrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CondBrOp CondBrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CondBrOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> CondBrOp::true_dest_operands(void) const & {
-  auto range = underlying_repr().getTrueDestOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> CondBrOp::false_dest_operands(void) const & {
-  auto range = underlying_repr().getFalseDestOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<ConstantOp> ConstantOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MLIR_CONSTANT) {
-    return reinterpret_cast<const ConstantOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ConstantOp> ConstantOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ConstantOp ConstantOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ConstantOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ConstantOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ExtractElementOp> ExtractElementOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_EXTRACTELEMENT) {
-    return reinterpret_cast<const ExtractElementOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExtractElementOp> ExtractElementOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ExtractElementOp ExtractElementOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ExtractElementOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ExtractElementOp::vector(void) const {
-  auto val = underlying_repr().getVector();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ExtractElementOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ExtractValueOp> ExtractValueOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_EXTRACTVALUE) {
-    return reinterpret_cast<const ExtractValueOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExtractValueOp> ExtractValueOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ExtractValueOp ExtractValueOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ExtractValueOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ExtractValueOp::container(void) const {
-  auto val = underlying_repr().getContainer();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ExtractValueOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FAddOp> FAddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FADD) {
-    return reinterpret_cast<const FAddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FAddOp> FAddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FAddOp FAddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FAddOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FAddOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FAddOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FAddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FCmpOp> FCmpOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FCMP) {
-    return reinterpret_cast<const FCmpOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FCmpOp> FCmpOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FCmpOp FCmpOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FCmpOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FCmpOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FCmpOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FCmpOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FDivOp> FDivOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FDIV) {
-    return reinterpret_cast<const FDivOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FDivOp> FDivOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FDivOp FDivOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FDivOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FDivOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FDivOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FDivOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FMulOp> FMulOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FMUL) {
-    return reinterpret_cast<const FMulOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FMulOp> FMulOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FMulOp FMulOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FMulOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FMulOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FMulOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FMulOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FNegOp> FNegOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FNEG) {
-    return reinterpret_cast<const FNegOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FNegOp> FNegOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FNegOp FNegOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FNegOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FNegOp::operand(void) const {
-  auto val = underlying_repr().getOperand();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FNegOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FPExtOp> FPExtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FPEXT) {
-    return reinterpret_cast<const FPExtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FPExtOp> FPExtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FPExtOp FPExtOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FPExtOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FPExtOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FPExtOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FPToSIOp> FPToSIOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FPTOSI) {
-    return reinterpret_cast<const FPToSIOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FPToSIOp> FPToSIOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FPToSIOp FPToSIOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FPToSIOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FPToSIOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FPToSIOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FPToUIOp> FPToUIOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FPTOUI) {
-    return reinterpret_cast<const FPToUIOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FPToUIOp> FPToUIOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FPToUIOp FPToUIOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FPToUIOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FPToUIOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FPToUIOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FPTruncOp> FPTruncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FPTRUNC) {
-    return reinterpret_cast<const FPTruncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FPTruncOp> FPTruncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FPTruncOp FPTruncOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FPTruncOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FPTruncOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FPTruncOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FRemOp> FRemOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FREM) {
-    return reinterpret_cast<const FRemOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FRemOp> FRemOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FRemOp FRemOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FRemOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FRemOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FRemOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FRemOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FSubOp> FSubOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FSUB) {
-    return reinterpret_cast<const FSubOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FSubOp> FSubOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FSubOp FSubOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FSubOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FSubOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FSubOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FSubOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FenceOp> FenceOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FENCE) {
-    return reinterpret_cast<const FenceOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FenceOp> FenceOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FenceOp FenceOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FenceOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<std::string_view> FenceOp::syncscope(void) const {
-  auto opt_val = underlying_repr().getSyncscope();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<FreezeOp> FreezeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FREEZE) {
-    return reinterpret_cast<const FreezeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FreezeOp> FreezeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FreezeOp FreezeOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FreezeOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FreezeOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FreezeOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<GetElementPtrOp> GetElementPtrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_GETELEMENTPTR) {
-    return reinterpret_cast<const GetElementPtrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GetElementPtrOp> GetElementPtrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::GEPOp GetElementPtrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::GEPOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value GetElementPtrOp::base(void) const {
-  auto val = underlying_repr().getBase();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> GetElementPtrOp::dynamic_indices(void) const & {
-  auto range = underlying_repr().getDynamicIndices();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value GetElementPtrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Type GetElementPtrOp::elem_type(void) const {
-  auto mlir_type = underlying_repr().getElemType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-bool GetElementPtrOp::inbounds(void) const {
-  auto val = underlying_repr().getInbounds();
-  return val;
-}
-
-std::optional<GlobalCtorsOp> GlobalCtorsOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MLIR_GLOBAL_CTORS) {
-    return reinterpret_cast<const GlobalCtorsOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GlobalCtorsOp> GlobalCtorsOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::GlobalCtorsOp GlobalCtorsOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::GlobalCtorsOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<GlobalDtorsOp> GlobalDtorsOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MLIR_GLOBAL_DTORS) {
-    return reinterpret_cast<const GlobalDtorsOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GlobalDtorsOp> GlobalDtorsOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::GlobalDtorsOp GlobalDtorsOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::GlobalDtorsOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<GlobalOp> GlobalOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MLIR_GLOBAL) {
-    return reinterpret_cast<const GlobalOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GlobalOp> GlobalOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::GlobalOp GlobalOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::GlobalOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region GlobalOp::initializer(void) const {
-  auto &val = underlying_repr().getInitializer();
-  return ::mx::ir::Region(module_, val);
-}
-
-::mx::ir::Type GlobalOp::global_type(void) const {
-  auto mlir_type = underlying_repr().getGlobalType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-bool GlobalOp::constant(void) const {
-  auto val = underlying_repr().getConstant();
-  return val;
-}
-
-std::string_view GlobalOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool GlobalOp::dso_local(void) const {
-  auto val = underlying_repr().getDsoLocal();
-  return val;
-}
-
-bool GlobalOp::thread_local__(void) const {
-  auto val = underlying_repr().getThreadLocal_();
-  return val;
-}
-
-std::optional<unsigned long long> GlobalOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-uint32_t GlobalOp::addr_space(void) const {
-  auto val = underlying_repr().getAddrSpace();
-  return val;
-}
-
-std::optional<std::string_view> GlobalOp::section(void) const {
-  auto opt_val = underlying_repr().getSection();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<ICmpOp> ICmpOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_ICMP) {
-    return reinterpret_cast<const ICmpOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ICmpOp> ICmpOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ICmpOp ICmpOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ICmpOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ICmpOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ICmpOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ICmpOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<InlineAsmOp> InlineAsmOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INLINE_ASM) {
-    return reinterpret_cast<const InlineAsmOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InlineAsmOp> InlineAsmOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::InlineAsmOp InlineAsmOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::InlineAsmOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> InlineAsmOp::operands(void) const & {
-  auto range = underlying_repr().getOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value InlineAsmOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::string_view InlineAsmOp::assembly(void) const {
-  auto val = underlying_repr().getAsmString();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::string_view InlineAsmOp::constraints(void) const {
-  auto val = underlying_repr().getConstraints();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool InlineAsmOp::has_side_effects(void) const {
-  auto val = underlying_repr().getHasSideEffects();
-  return val;
-}
-
-bool InlineAsmOp::is_align_stack(void) const {
-  auto val = underlying_repr().getIsAlignStack();
-  return val;
-}
-
-std::optional<InsertElementOp> InsertElementOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INSERTELEMENT) {
-    return reinterpret_cast<const InsertElementOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InsertElementOp> InsertElementOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::InsertElementOp InsertElementOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::InsertElementOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value InsertElementOp::vector(void) const {
-  auto val = underlying_repr().getVector();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value InsertElementOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value InsertElementOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<InsertValueOp> InsertValueOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INSERTVALUE) {
-    return reinterpret_cast<const InsertValueOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InsertValueOp> InsertValueOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::InsertValueOp InsertValueOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::InsertValueOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value InsertValueOp::container(void) const {
-  auto val = underlying_repr().getContainer();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value InsertValueOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value InsertValueOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<IntToPtrOp> IntToPtrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTTOPTR) {
-    return reinterpret_cast<const IntToPtrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<IntToPtrOp> IntToPtrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::IntToPtrOp IntToPtrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::IntToPtrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value IntToPtrOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value IntToPtrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<InvokeOp> InvokeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INVOKE) {
-    return reinterpret_cast<const InvokeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InvokeOp> InvokeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::InvokeOp InvokeOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::InvokeOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> InvokeOp::callee_operands(void) const & {
-  auto range = underlying_repr().getCalleeOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> InvokeOp::normal_dest_operands(void) const & {
-  auto range = underlying_repr().getNormalDestOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> InvokeOp::unwind_dest_operands(void) const & {
-  auto range = underlying_repr().getUnwindDestOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<std::string_view> InvokeOp::callee(void) const {
-  auto opt_val = underlying_repr().getCallee();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-gap::generator<::mx::ir::Operand> InvokeOp::arg_operands(void) const & {
-  auto range = underlying_repr().getArgOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<FuncOp> FuncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_FUNC) {
-    return reinterpret_cast<const FuncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FuncOp> FuncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LLVMFuncOp FuncOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LLVMFuncOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<::mx::ir::Region> FuncOp::body(void) const {
-  decltype(auto) opt_val = underlying_repr().getBody();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view FuncOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<std::string_view> FuncOp::visibility(void) const {
-  auto opt_val = underlying_repr().getSymVisibility();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool FuncOp::dso_local(void) const {
-  auto val = underlying_repr().getDsoLocal();
-  return val;
-}
-
-std::optional<std::string_view> FuncOp::personality(void) const {
-  auto opt_val = underlying_repr().getPersonality();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<std::string_view> FuncOp::garbage_collector(void) const {
-  auto opt_val = underlying_repr().getGarbageCollector();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<unsigned long long> FuncOp::function_entry_count(void) const {
-  auto opt_val = underlying_repr().getFunctionEntryCount();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<bool> FuncOp::arm_streaming(void) const {
-  auto opt_val = underlying_repr().getArmStreaming();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<bool> FuncOp::arm_locally_streaming(void) const {
-  auto opt_val = underlying_repr().getArmLocallyStreaming();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<bool> FuncOp::arm_streaming_compatible(void) const {
-  auto opt_val = underlying_repr().getArmStreamingCompatible();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<bool> FuncOp::arm_new_za(void) const {
-  auto opt_val = underlying_repr().getArmNewZa();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<bool> FuncOp::arm_preserves_za(void) const {
-  auto opt_val = underlying_repr().getArmPreservesZa();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<bool> FuncOp::arm_shared_za(void) const {
-  auto opt_val = underlying_repr().getArmSharedZa();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<std::string_view> FuncOp::section(void) const {
-  auto opt_val = underlying_repr().getSection();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<unsigned long long> FuncOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<std::string_view> FuncOp::target_cpu(void) const {
-  auto opt_val = underlying_repr().getTargetCpu();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool FuncOp::is_var_arg(void) const {
-  auto val = underlying_repr().isVarArg();
-  return val;
-}
-
-std::optional<LShrOp> LShrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_LSHR) {
-    return reinterpret_cast<const LShrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LShrOp> LShrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LShrOp LShrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LShrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value LShrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value LShrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value LShrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<LandingpadOp> LandingpadOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_LANDINGPAD) {
-    return reinterpret_cast<const LandingpadOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LandingpadOp> LandingpadOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LandingpadOp LandingpadOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LandingpadOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value LandingpadOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-bool LandingpadOp::cleanup(void) const {
-  auto val = underlying_repr().getCleanup();
-  return val;
-}
-
-std::optional<LinkerOptionsOp> LinkerOptionsOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_LINKER_OPTIONS) {
-    return reinterpret_cast<const LinkerOptionsOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LinkerOptionsOp> LinkerOptionsOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LinkerOptionsOp LinkerOptionsOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LinkerOptionsOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<LoadOp> LoadOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_LOAD) {
-    return reinterpret_cast<const LoadOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LoadOp> LoadOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LoadOp LoadOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LoadOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value LoadOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<unsigned long long> LoadOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-bool LoadOp::volatile__(void) const {
-  auto val = underlying_repr().getVolatile_();
-  return val;
-}
-
-bool LoadOp::nontemporal(void) const {
-  auto val = underlying_repr().getNontemporal();
-  return val;
-}
-
-bool LoadOp::invariant(void) const {
-  auto val = underlying_repr().getInvariant();
-  return val;
-}
-
-std::optional<std::string_view> LoadOp::syncscope(void) const {
-  auto opt_val = underlying_repr().getSyncscope();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<MulOp> MulOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MUL) {
-    return reinterpret_cast<const MulOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MulOp> MulOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MulOp MulOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MulOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MulOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MulOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<NoneTokenOp> NoneTokenOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MLIR_NONE) {
-    return reinterpret_cast<const NoneTokenOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<NoneTokenOp> NoneTokenOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::NoneTokenOp NoneTokenOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::NoneTokenOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value NoneTokenOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<OrOp> OrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_OR) {
-    return reinterpret_cast<const OrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<OrOp> OrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::OrOp OrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::OrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value OrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value OrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value OrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PoisonOp> PoisonOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MLIR_POISON) {
-    return reinterpret_cast<const PoisonOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PoisonOp> PoisonOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::PoisonOp PoisonOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::PoisonOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PoisonOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PtrToIntOp> PtrToIntOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_PTRTOINT) {
-    return reinterpret_cast<const PtrToIntOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PtrToIntOp> PtrToIntOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::PtrToIntOp PtrToIntOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::PtrToIntOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PtrToIntOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value PtrToIntOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ResumeOp> ResumeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_RESUME) {
-    return reinterpret_cast<const ResumeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ResumeOp> ResumeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ResumeOp ResumeOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ResumeOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ResumeOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ReturnOp> ReturnOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_RETURN) {
-    return reinterpret_cast<const ReturnOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ReturnOp> ReturnOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ReturnOp ReturnOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ReturnOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ReturnOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SDivOp> SDivOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_SDIV) {
-    return reinterpret_cast<const SDivOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SDivOp> SDivOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SDivOp SDivOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SDivOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SDivOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SDivOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SDivOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SExtOp> SExtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_SEXT) {
-    return reinterpret_cast<const SExtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SExtOp> SExtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SExtOp SExtOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SExtOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SExtOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SExtOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SIToFPOp> SIToFPOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_SITOFP) {
-    return reinterpret_cast<const SIToFPOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SIToFPOp> SIToFPOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SIToFPOp SIToFPOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SIToFPOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SIToFPOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SIToFPOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SRemOp> SRemOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_SREM) {
-    return reinterpret_cast<const SRemOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SRemOp> SRemOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SRemOp SRemOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SRemOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SRemOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SRemOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SRemOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SelectOp> SelectOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_SELECT) {
-    return reinterpret_cast<const SelectOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SelectOp> SelectOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SelectOp SelectOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SelectOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SelectOp::condition(void) const {
-  auto val = underlying_repr().getCondition();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SelectOp::true_value(void) const {
-  auto val = underlying_repr().getTrueValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SelectOp::false_value(void) const {
-  auto val = underlying_repr().getFalseValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SelectOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ShlOp> ShlOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_SHL) {
-    return reinterpret_cast<const ShlOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ShlOp> ShlOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ShlOp ShlOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ShlOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ShlOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ShlOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ShlOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ShuffleVectorOp> ShuffleVectorOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_SHUFFLEVECTOR) {
-    return reinterpret_cast<const ShuffleVectorOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ShuffleVectorOp> ShuffleVectorOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ShuffleVectorOp ShuffleVectorOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ShuffleVectorOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ShuffleVectorOp::v1(void) const {
-  auto val = underlying_repr().getV1();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ShuffleVectorOp::v2(void) const {
-  auto val = underlying_repr().getV2();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ShuffleVectorOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<StoreOp> StoreOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_STORE) {
-    return reinterpret_cast<const StoreOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StoreOp> StoreOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::StoreOp StoreOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::StoreOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value StoreOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<unsigned long long> StoreOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-bool StoreOp::volatile__(void) const {
-  auto val = underlying_repr().getVolatile_();
-  return val;
-}
-
-bool StoreOp::nontemporal(void) const {
-  auto val = underlying_repr().getNontemporal();
-  return val;
-}
-
-std::optional<std::string_view> StoreOp::syncscope(void) const {
-  auto opt_val = underlying_repr().getSyncscope();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<SubOp> SubOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_SUB) {
-    return reinterpret_cast<const SubOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SubOp> SubOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SubOp SubOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SubOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SubOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SwitchOp> SwitchOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_SWITCH) {
-    return reinterpret_cast<const SwitchOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SwitchOp> SwitchOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SwitchOp SwitchOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SwitchOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> SwitchOp::default_operands(void) const & {
-  auto range = underlying_repr().getDefaultOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<TruncOp> TruncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_TRUNC) {
-    return reinterpret_cast<const TruncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TruncOp> TruncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::TruncOp TruncOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::TruncOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value TruncOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value TruncOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UDivOp> UDivOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_UDIV) {
-    return reinterpret_cast<const UDivOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UDivOp> UDivOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UDivOp UDivOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UDivOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UDivOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UDivOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UDivOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UIToFPOp> UIToFPOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_UITOFP) {
-    return reinterpret_cast<const UIToFPOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UIToFPOp> UIToFPOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UIToFPOp UIToFPOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UIToFPOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UIToFPOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UIToFPOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<URemOp> URemOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_UREM) {
-    return reinterpret_cast<const URemOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<URemOp> URemOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::URemOp URemOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::URemOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value URemOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value URemOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value URemOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UndefOp> UndefOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MLIR_UNDEF) {
-    return reinterpret_cast<const UndefOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UndefOp> UndefOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UndefOp UndefOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UndefOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UndefOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UnreachableOp> UnreachableOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_UNREACHABLE) {
-    return reinterpret_cast<const UnreachableOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UnreachableOp> UnreachableOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UnreachableOp UnreachableOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UnreachableOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<XOrOp> XOrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_XOR) {
-    return reinterpret_cast<const XOrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<XOrOp> XOrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::XOrOp XOrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::XOrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value XOrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value XOrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value XOrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ZExtOp> ZExtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_ZEXT) {
-    return reinterpret_cast<const ZExtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ZExtOp> ZExtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ZExtOp ZExtOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ZExtOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ZExtOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ZExtOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ZeroOp> ZeroOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_MLIR_ZERO) {
-    return reinterpret_cast<const ZeroOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ZeroOp> ZeroOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ZeroOp ZeroOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ZeroOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ZeroOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AbsOp> AbsOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_ABS) {
-    return reinterpret_cast<const AbsOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AbsOp> AbsOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AbsOp AbsOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AbsOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AbsOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value AbsOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-bool AbsOp::is_int_min_poison(void) const {
-  auto val = underlying_repr().getIsIntMinPoison();
-  return val;
-}
-
-std::optional<AnnotationOp> AnnotationOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_ANNOTATION) {
-    return reinterpret_cast<const AnnotationOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AnnotationOp> AnnotationOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::Annotation AnnotationOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::Annotation(this->::mx::ir::Operation::op_);
-}
-
-std::optional<AssumeOp> AssumeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_ASSUME) {
-    return reinterpret_cast<const AssumeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AssumeOp> AssumeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::AssumeOp AssumeOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::AssumeOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<BitReverseOp> BitReverseOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_BITREVERSE) {
-    return reinterpret_cast<const BitReverseOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BitReverseOp> BitReverseOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::BitReverseOp BitReverseOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::BitReverseOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value BitReverseOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value BitReverseOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ByteSwapOp> ByteSwapOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_BSWAP) {
-    return reinterpret_cast<const ByteSwapOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ByteSwapOp> ByteSwapOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ByteSwapOp ByteSwapOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ByteSwapOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ByteSwapOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ByteSwapOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CopySignOp> CopySignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_COPYSIGN) {
-    return reinterpret_cast<const CopySignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CopySignOp> CopySignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CopySignOp CopySignOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CopySignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CopySignOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CopySignOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CopySignOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CoroAlignOp> CoroAlignOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_ALIGN) {
-    return reinterpret_cast<const CoroAlignOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroAlignOp> CoroAlignOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroAlignOp CoroAlignOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroAlignOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CoroAlignOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CoroBeginOp> CoroBeginOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_BEGIN) {
-    return reinterpret_cast<const CoroBeginOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroBeginOp> CoroBeginOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroBeginOp CoroBeginOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroBeginOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CoroBeginOp::token(void) const {
-  auto val = underlying_repr().getToken();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CoroBeginOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CoroEndOp> CoroEndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_END) {
-    return reinterpret_cast<const CoroEndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroEndOp> CoroEndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroEndOp CoroEndOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroEndOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CoroEndOp::retvals(void) const {
-  auto val = underlying_repr().getRetvals();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CoroEndOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CoroFreeOp> CoroFreeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_FREE) {
-    return reinterpret_cast<const CoroFreeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroFreeOp> CoroFreeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroFreeOp CoroFreeOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroFreeOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CoroFreeOp::id(void) const {
-  auto val = underlying_repr().getId();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CoroFreeOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CoroIdOp> CoroIdOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_ID) {
-    return reinterpret_cast<const CoroIdOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroIdOp> CoroIdOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroIdOp CoroIdOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroIdOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CoroIdOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CoroPromiseOp> CoroPromiseOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_PROMISE) {
-    return reinterpret_cast<const CoroPromiseOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroPromiseOp> CoroPromiseOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroPromiseOp CoroPromiseOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroPromiseOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<CoroResumeOp> CoroResumeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_RESUME) {
-    return reinterpret_cast<const CoroResumeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroResumeOp> CoroResumeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroResumeOp CoroResumeOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroResumeOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<CoroSaveOp> CoroSaveOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_SAVE) {
-    return reinterpret_cast<const CoroSaveOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroSaveOp> CoroSaveOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroSaveOp CoroSaveOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroSaveOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CoroSaveOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CoroSizeOp> CoroSizeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_SIZE) {
-    return reinterpret_cast<const CoroSizeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroSizeOp> CoroSizeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroSizeOp CoroSizeOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroSizeOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CoroSizeOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CoroSuspendOp> CoroSuspendOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CORO_SUSPEND) {
-    return reinterpret_cast<const CoroSuspendOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CoroSuspendOp> CoroSuspendOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CoroSuspendOp CoroSuspendOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CoroSuspendOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CoroSuspendOp::save(void) const {
-  auto val = underlying_repr().getSave();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CoroSuspendOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CosOp> CosOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_COS) {
-    return reinterpret_cast<const CosOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CosOp> CosOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CosOp CosOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CosOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CosOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CosOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CountLeadingZerosOp> CountLeadingZerosOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CTLZ) {
-    return reinterpret_cast<const CountLeadingZerosOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CountLeadingZerosOp> CountLeadingZerosOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CountLeadingZerosOp CountLeadingZerosOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CountLeadingZerosOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CountLeadingZerosOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CountLeadingZerosOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-bool CountLeadingZerosOp::is_zero_poison(void) const {
-  auto val = underlying_repr().getIsZeroPoison();
-  return val;
-}
-
-std::optional<CountTrailingZerosOp> CountTrailingZerosOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CTTZ) {
-    return reinterpret_cast<const CountTrailingZerosOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CountTrailingZerosOp> CountTrailingZerosOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CountTrailingZerosOp CountTrailingZerosOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CountTrailingZerosOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CountTrailingZerosOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CountTrailingZerosOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-bool CountTrailingZerosOp::is_zero_poison(void) const {
-  auto val = underlying_repr().getIsZeroPoison();
-  return val;
-}
-
-std::optional<CtPopOp> CtPopOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CTPOP) {
-    return reinterpret_cast<const CtPopOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CtPopOp> CtPopOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::CtPopOp CtPopOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::CtPopOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CtPopOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value CtPopOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DbgDeclareOp> DbgDeclareOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_DBG_DECLARE) {
-    return reinterpret_cast<const DbgDeclareOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DbgDeclareOp> DbgDeclareOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DbgDeclareOp DbgDeclareOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DbgDeclareOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<DbgLabelOp> DbgLabelOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_DBG_LABEL) {
-    return reinterpret_cast<const DbgLabelOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DbgLabelOp> DbgLabelOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DbgLabelOp DbgLabelOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DbgLabelOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<DbgValueOp> DbgValueOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_DBG_VALUE) {
-    return reinterpret_cast<const DbgValueOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DbgValueOp> DbgValueOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DbgValueOp DbgValueOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DbgValueOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DbgValueOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<DebugTrapOp> DebugTrapOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_DEBUGTRAP) {
-    return reinterpret_cast<const DebugTrapOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DebugTrapOp> DebugTrapOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::DebugTrap DebugTrapOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::DebugTrap(this->::mx::ir::Operation::op_);
-}
-
-std::optional<EhTypeidForOp> EhTypeidForOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_EH_TYPEID_FOR) {
-    return reinterpret_cast<const EhTypeidForOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<EhTypeidForOp> EhTypeidForOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::EhTypeidForOp EhTypeidForOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::EhTypeidForOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value EhTypeidForOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<Exp2Op> Exp2Op::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_EXP2) {
-    return reinterpret_cast<const Exp2Op &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<Exp2Op> Exp2Op::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::Exp2Op Exp2Op::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::Exp2Op(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value Exp2Op::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value Exp2Op::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ExpOp> ExpOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_EXP) {
-    return reinterpret_cast<const ExpOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExpOp> ExpOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ExpOp ExpOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ExpOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ExpOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ExpOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ExpectOp> ExpectOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_EXPECT) {
-    return reinterpret_cast<const ExpectOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExpectOp> ExpectOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ExpectOp ExpectOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ExpectOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ExpectOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ExpectWithProbabilityOp> ExpectWithProbabilityOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_EXPECT_WITH_PROBABILITY) {
-    return reinterpret_cast<const ExpectWithProbabilityOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExpectWithProbabilityOp> ExpectWithProbabilityOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ExpectWithProbabilityOp ExpectWithProbabilityOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ExpectWithProbabilityOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ExpectWithProbabilityOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FAbsOp> FAbsOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_FABS) {
-    return reinterpret_cast<const FAbsOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FAbsOp> FAbsOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FAbsOp FAbsOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FAbsOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FAbsOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FAbsOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FCeilOp> FCeilOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_CEIL) {
-    return reinterpret_cast<const FCeilOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FCeilOp> FCeilOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FCeilOp FCeilOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FCeilOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FCeilOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FCeilOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FFloorOp> FFloorOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_FLOOR) {
-    return reinterpret_cast<const FFloorOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FFloorOp> FFloorOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FFloorOp FFloorOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FFloorOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FFloorOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FFloorOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FMAOp> FMAOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_FMA) {
-    return reinterpret_cast<const FMAOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FMAOp> FMAOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FMAOp FMAOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FMAOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FMAOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FMAOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FMAOp::c(void) const {
-  auto val = underlying_repr().getC();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FMAOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FMulAddOp> FMulAddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_FMULADD) {
-    return reinterpret_cast<const FMulAddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FMulAddOp> FMulAddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FMulAddOp FMulAddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FMulAddOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FMulAddOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FMulAddOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FMulAddOp::c(void) const {
-  auto val = underlying_repr().getC();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FMulAddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FTruncOp> FTruncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_TRUNC) {
-    return reinterpret_cast<const FTruncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FTruncOp> FTruncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FTruncOp FTruncOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FTruncOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FTruncOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FTruncOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FShlOp> FShlOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_FSHL) {
-    return reinterpret_cast<const FShlOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FShlOp> FShlOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FshlOp FShlOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FshlOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FShlOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FShlOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FShlOp::c(void) const {
-  auto val = underlying_repr().getC();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FShlOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FShrOp> FShrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_FSHR) {
-    return reinterpret_cast<const FShrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FShrOp> FShrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::FshrOp FShrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::FshrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FShrOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FShrOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FShrOp::c(void) const {
-  auto val = underlying_repr().getC();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FShrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<GetActiveLaneMaskOp> GetActiveLaneMaskOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_GET_ACTIVE_LANE_MASK) {
-    return reinterpret_cast<const GetActiveLaneMaskOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GetActiveLaneMaskOp> GetActiveLaneMaskOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::GetActiveLaneMaskOp GetActiveLaneMaskOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::GetActiveLaneMaskOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value GetActiveLaneMaskOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<InvariantEndOp> InvariantEndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_INVARIANT_END) {
-    return reinterpret_cast<const InvariantEndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InvariantEndOp> InvariantEndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::InvariantEndOp InvariantEndOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::InvariantEndOp(this->::mx::ir::Operation::op_);
-}
-
-uint64_t InvariantEndOp::size(void) const {
-  auto val = underlying_repr().getSize();
-  return val;
-}
-
-std::optional<InvariantStartOp> InvariantStartOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_INVARIANT_START) {
-    return reinterpret_cast<const InvariantStartOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InvariantStartOp> InvariantStartOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::InvariantStartOp InvariantStartOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::InvariantStartOp(this->::mx::ir::Operation::op_);
-}
-
-uint64_t InvariantStartOp::size(void) const {
-  auto val = underlying_repr().getSize();
-  return val;
-}
-
-std::optional<IsConstantOp> IsConstantOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_IS_CONSTANT) {
-    return reinterpret_cast<const IsConstantOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<IsConstantOp> IsConstantOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::IsConstantOp IsConstantOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::IsConstantOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value IsConstantOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<IsFPClassOp> IsFPClassOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_IS_FPCLASS) {
-    return reinterpret_cast<const IsFPClassOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<IsFPClassOp> IsFPClassOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::IsFPClass IsFPClassOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::IsFPClass(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value IsFPClassOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value IsFPClassOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint32_t IsFPClassOp::bit(void) const {
-  auto val = underlying_repr().getBit();
-  return val;
-}
-
-std::optional<LifetimeEndOp> LifetimeEndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_LIFETIME_END) {
-    return reinterpret_cast<const LifetimeEndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LifetimeEndOp> LifetimeEndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LifetimeEndOp LifetimeEndOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LifetimeEndOp(this->::mx::ir::Operation::op_);
-}
-
-uint64_t LifetimeEndOp::size(void) const {
-  auto val = underlying_repr().getSize();
-  return val;
-}
-
-std::optional<LifetimeStartOp> LifetimeStartOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_LIFETIME_START) {
-    return reinterpret_cast<const LifetimeStartOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LifetimeStartOp> LifetimeStartOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LifetimeStartOp LifetimeStartOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LifetimeStartOp(this->::mx::ir::Operation::op_);
-}
-
-uint64_t LifetimeStartOp::size(void) const {
-  auto val = underlying_repr().getSize();
-  return val;
-}
-
-std::optional<RoundAndCastToLongLongOp> RoundAndCastToLongLongOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_LLRINT) {
-    return reinterpret_cast<const RoundAndCastToLongLongOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RoundAndCastToLongLongOp> RoundAndCastToLongLongOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LlrintOp RoundAndCastToLongLongOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LlrintOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RoundAndCastToLongLongOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RoundAndCastToLongLongOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RoundAndCastToNearestLongLongOp> RoundAndCastToNearestLongLongOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_LLROUND) {
-    return reinterpret_cast<const RoundAndCastToNearestLongLongOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RoundAndCastToNearestLongLongOp> RoundAndCastToNearestLongLongOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LlroundOp RoundAndCastToNearestLongLongOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LlroundOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RoundAndCastToNearestLongLongOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RoundAndCastToNearestLongLongOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<Log10Op> Log10Op::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_LOG10) {
-    return reinterpret_cast<const Log10Op &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<Log10Op> Log10Op::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::Log10Op Log10Op::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::Log10Op(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value Log10Op::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value Log10Op::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<Log2Op> Log2Op::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_LOG2) {
-    return reinterpret_cast<const Log2Op &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<Log2Op> Log2Op::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::Log2Op Log2Op::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::Log2Op(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value Log2Op::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value Log2Op::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<LogOp> LogOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_LOG) {
-    return reinterpret_cast<const LogOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LogOp> LogOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LogOp LogOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LogOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value LogOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value LogOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RoundAndCastToLongOp> RoundAndCastToLongOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_LRINT) {
-    return reinterpret_cast<const RoundAndCastToLongOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RoundAndCastToLongOp> RoundAndCastToLongOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LrintOp RoundAndCastToLongOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LrintOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RoundAndCastToLongOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RoundAndCastToLongOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RoundAndCastToNearestLongOp> RoundAndCastToNearestLongOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_LROUND) {
-    return reinterpret_cast<const RoundAndCastToNearestLongOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RoundAndCastToNearestLongOp> RoundAndCastToNearestLongOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LroundOp RoundAndCastToNearestLongOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LroundOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RoundAndCastToNearestLongOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RoundAndCastToNearestLongOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<MaskedLoadOp> MaskedLoadOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MASKED_LOAD) {
-    return reinterpret_cast<const MaskedLoadOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MaskedLoadOp> MaskedLoadOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MaskedLoadOp MaskedLoadOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MaskedLoadOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MaskedLoadOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> MaskedLoadOp::pass_thru(void) const & {
-  auto range = underlying_repr().getPassThru();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value MaskedLoadOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint32_t MaskedLoadOp::alignment(void) const {
-  auto val = underlying_repr().getAlignment();
-  return val;
-}
-
-std::optional<MaskedStoreOp> MaskedStoreOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MASKED_STORE) {
-    return reinterpret_cast<const MaskedStoreOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MaskedStoreOp> MaskedStoreOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MaskedStoreOp MaskedStoreOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MaskedStoreOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MaskedStoreOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MaskedStoreOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint32_t MaskedStoreOp::alignment(void) const {
-  auto val = underlying_repr().getAlignment();
-  return val;
-}
-
-std::optional<MatrixColumnMajorLoadOp> MatrixColumnMajorLoadOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_LOAD) {
-    return reinterpret_cast<const MatrixColumnMajorLoadOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MatrixColumnMajorLoadOp> MatrixColumnMajorLoadOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MatrixColumnMajorLoadOp MatrixColumnMajorLoadOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MatrixColumnMajorLoadOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MatrixColumnMajorLoadOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-bool MatrixColumnMajorLoadOp::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-uint32_t MatrixColumnMajorLoadOp::rows(void) const {
-  auto val = underlying_repr().getRows();
-  return val;
-}
-
-uint32_t MatrixColumnMajorLoadOp::columns(void) const {
-  auto val = underlying_repr().getColumns();
-  return val;
-}
-
-std::optional<MatrixColumnMajorStoreOp> MatrixColumnMajorStoreOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_STORE) {
-    return reinterpret_cast<const MatrixColumnMajorStoreOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MatrixColumnMajorStoreOp> MatrixColumnMajorStoreOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MatrixColumnMajorStoreOp MatrixColumnMajorStoreOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MatrixColumnMajorStoreOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MatrixColumnMajorStoreOp::matrix(void) const {
-  auto val = underlying_repr().getMatrix();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-bool MatrixColumnMajorStoreOp::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-uint32_t MatrixColumnMajorStoreOp::rows(void) const {
-  auto val = underlying_repr().getRows();
-  return val;
-}
-
-uint32_t MatrixColumnMajorStoreOp::columns(void) const {
-  auto val = underlying_repr().getColumns();
-  return val;
-}
-
-std::optional<MatrixMultiplyOp> MatrixMultiplyOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MATRIX_MULTIPLY) {
-    return reinterpret_cast<const MatrixMultiplyOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MatrixMultiplyOp> MatrixMultiplyOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MatrixMultiplyOp MatrixMultiplyOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MatrixMultiplyOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MatrixMultiplyOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MatrixMultiplyOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MatrixMultiplyOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint32_t MatrixMultiplyOp::lhs_rows(void) const {
-  auto val = underlying_repr().getLhsRows();
-  return val;
-}
-
-uint32_t MatrixMultiplyOp::lhs_columns(void) const {
-  auto val = underlying_repr().getLhsColumns();
-  return val;
-}
-
-uint32_t MatrixMultiplyOp::rhs_columns(void) const {
-  auto val = underlying_repr().getRhsColumns();
-  return val;
-}
-
-std::optional<MatrixTransposeOp> MatrixTransposeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MATRIX_TRANSPOSE) {
-    return reinterpret_cast<const MatrixTransposeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MatrixTransposeOp> MatrixTransposeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MatrixTransposeOp MatrixTransposeOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MatrixTransposeOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MatrixTransposeOp::matrix(void) const {
-  auto val = underlying_repr().getMatrix();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MatrixTransposeOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint32_t MatrixTransposeOp::rows(void) const {
-  auto val = underlying_repr().getRows();
-  return val;
-}
-
-uint32_t MatrixTransposeOp::columns(void) const {
-  auto val = underlying_repr().getColumns();
-  return val;
-}
-
-std::optional<MaxNumOp> MaxNumOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MAXNUM) {
-    return reinterpret_cast<const MaxNumOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MaxNumOp> MaxNumOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MaxNumOp MaxNumOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MaxNumOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MaxNumOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MaxNumOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MaxNumOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<MaximumOp> MaximumOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MAXIMUM) {
-    return reinterpret_cast<const MaximumOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MaximumOp> MaximumOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MaximumOp MaximumOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MaximumOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MaximumOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MaximumOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MaximumOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<MemcpyInlineOp> MemcpyInlineOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MEMCPY_INLINE) {
-    return reinterpret_cast<const MemcpyInlineOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MemcpyInlineOp> MemcpyInlineOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MemcpyInlineOp MemcpyInlineOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MemcpyInlineOp(this->::mx::ir::Operation::op_);
-}
-
-bool MemcpyInlineOp::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-std::optional<MemcpyOp> MemcpyOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MEMCPY) {
-    return reinterpret_cast<const MemcpyOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MemcpyOp> MemcpyOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MemcpyOp MemcpyOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MemcpyOp(this->::mx::ir::Operation::op_);
-}
-
-bool MemcpyOp::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-std::optional<MemmoveOp> MemmoveOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MEMMOVE) {
-    return reinterpret_cast<const MemmoveOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MemmoveOp> MemmoveOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MemmoveOp MemmoveOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MemmoveOp(this->::mx::ir::Operation::op_);
-}
-
-bool MemmoveOp::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-std::optional<MemsetOp> MemsetOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MEMSET) {
-    return reinterpret_cast<const MemsetOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MemsetOp> MemsetOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MemsetOp MemsetOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MemsetOp(this->::mx::ir::Operation::op_);
-}
-
-bool MemsetOp::is_volatile(void) const {
-  auto val = underlying_repr().getIsVolatile();
-  return val;
-}
-
-std::optional<MinNumOp> MinNumOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MINNUM) {
-    return reinterpret_cast<const MinNumOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MinNumOp> MinNumOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MinNumOp MinNumOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MinNumOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MinNumOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MinNumOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MinNumOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<MinimumOp> MinimumOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MINIMUM) {
-    return reinterpret_cast<const MinimumOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MinimumOp> MinimumOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::MinimumOp MinimumOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::MinimumOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MinimumOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MinimumOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MinimumOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RoundToNearbyIntOp> RoundToNearbyIntOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_NEARBYINT) {
-    return reinterpret_cast<const RoundToNearbyIntOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RoundToNearbyIntOp> RoundToNearbyIntOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::NearbyintOp RoundToNearbyIntOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::NearbyintOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RoundToNearbyIntOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RoundToNearbyIntOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<NoAliasScopeDeclOp> NoAliasScopeDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_EXPERIMENTAL_NOALIAS_SCOPE_DECL) {
-    return reinterpret_cast<const NoAliasScopeDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<NoAliasScopeDeclOp> NoAliasScopeDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::NoAliasScopeDeclOp NoAliasScopeDeclOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::NoAliasScopeDeclOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<PowIOp> PowIOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_POWI) {
-    return reinterpret_cast<const PowIOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PowIOp> PowIOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::PowIOp PowIOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::PowIOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value PowIOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value PowIOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FPowOp> FPowOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_POW) {
-    return reinterpret_cast<const FPowOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FPowOp> FPowOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::PowOp FPowOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::PowOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value FPowOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FPowOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value FPowOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<PrefetchOp> PrefetchOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_PREFETCH) {
-    return reinterpret_cast<const PrefetchOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PrefetchOp> PrefetchOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::Prefetch PrefetchOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::Prefetch(this->::mx::ir::Operation::op_);
-}
-
-uint32_t PrefetchOp::rw(void) const {
-  auto val = underlying_repr().getRw();
-  return val;
-}
-
-uint32_t PrefetchOp::hint(void) const {
-  auto val = underlying_repr().getHint();
-  return val;
-}
-
-uint32_t PrefetchOp::cache(void) const {
-  auto val = underlying_repr().getCache();
-  return val;
-}
-
-std::optional<PtrAnnotationOp> PtrAnnotationOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_PTR_ANNOTATION) {
-    return reinterpret_cast<const PtrAnnotationOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PtrAnnotationOp> PtrAnnotationOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::PtrAnnotation PtrAnnotationOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::PtrAnnotation(this->::mx::ir::Operation::op_);
-}
-
-std::optional<RoundToIntOp> RoundToIntOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_RINT) {
-    return reinterpret_cast<const RoundToIntOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RoundToIntOp> RoundToIntOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::RintOp RoundToIntOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::RintOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RoundToIntOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RoundToIntOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RoundToNearestEvenOp> RoundToNearestEvenOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_ROUNDEVEN) {
-    return reinterpret_cast<const RoundToNearestEvenOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RoundToNearestEvenOp> RoundToNearestEvenOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::RoundEvenOp RoundToNearestEvenOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::RoundEvenOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RoundToNearestEvenOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RoundToNearestEvenOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<RoundToNearestOp> RoundToNearestOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_ROUND) {
-    return reinterpret_cast<const RoundToNearestOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RoundToNearestOp> RoundToNearestOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::RoundOp RoundToNearestOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::RoundOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value RoundToNearestOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value RoundToNearestOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SAddSatOp> SAddSatOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SADD_SAT) {
-    return reinterpret_cast<const SAddSatOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SAddSatOp> SAddSatOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SAddSat SAddSatOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SAddSat(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SAddSatOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SAddSatOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SAddSatOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SAddWithOverflowOp> SAddWithOverflowOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SADD_WITH_OVERFLOW) {
-    return reinterpret_cast<const SAddWithOverflowOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SAddWithOverflowOp> SAddWithOverflowOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SAddWithOverflowOp SAddWithOverflowOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SAddWithOverflowOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SAddWithOverflowOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SMaxOp> SMaxOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SMAX) {
-    return reinterpret_cast<const SMaxOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SMaxOp> SMaxOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SMaxOp SMaxOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SMaxOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SMaxOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SMaxOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SMaxOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SMinOp> SMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SMIN) {
-    return reinterpret_cast<const SMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SMinOp> SMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SMinOp SMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SMinOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SMinOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SMinOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SMulWithOverflowOp> SMulWithOverflowOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SMUL_WITH_OVERFLOW) {
-    return reinterpret_cast<const SMulWithOverflowOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SMulWithOverflowOp> SMulWithOverflowOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SMulWithOverflowOp SMulWithOverflowOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SMulWithOverflowOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SMulWithOverflowOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SSACopyOp> SSACopyOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SSA_COPY) {
-    return reinterpret_cast<const SSACopyOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SSACopyOp> SSACopyOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SSACopyOp SSACopyOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SSACopyOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SSACopyOp::operand(void) const {
-  auto val = underlying_repr().getOperand();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SSACopyOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SShlSatOp> SShlSatOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SSHL_SAT) {
-    return reinterpret_cast<const SShlSatOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SShlSatOp> SShlSatOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SSHLSat SShlSatOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SSHLSat(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SShlSatOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SShlSatOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SShlSatOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SSubSatOp> SSubSatOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SSUB_SAT) {
-    return reinterpret_cast<const SSubSatOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SSubSatOp> SSubSatOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SSubSat SSubSatOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SSubSat(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SSubSatOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SSubSatOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SSubSatOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SSubWithOverflowOp> SSubWithOverflowOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SSUB_WITH_OVERFLOW) {
-    return reinterpret_cast<const SSubWithOverflowOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SSubWithOverflowOp> SSubWithOverflowOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SSubWithOverflowOp SSubWithOverflowOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SSubWithOverflowOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SSubWithOverflowOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SinOp> SinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SIN) {
-    return reinterpret_cast<const SinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SinOp> SinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SinOp SinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SinOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SinOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SqrtOp> SqrtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_SQRT) {
-    return reinterpret_cast<const SqrtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SqrtOp> SqrtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::SqrtOp SqrtOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::SqrtOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SqrtOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SqrtOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<StackRestoreOp> StackRestoreOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_STACKRESTORE) {
-    return reinterpret_cast<const StackRestoreOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StackRestoreOp> StackRestoreOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::StackRestoreOp StackRestoreOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::StackRestoreOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<StackSaveOp> StackSaveOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_STACKSAVE) {
-    return reinterpret_cast<const StackSaveOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StackSaveOp> StackSaveOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::StackSaveOp StackSaveOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::StackSaveOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value StackSaveOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<StepVectorOp> StepVectorOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_EXPERIMENTAL_STEPVECTOR) {
-    return reinterpret_cast<const StepVectorOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StepVectorOp> StepVectorOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::StepVectorOp StepVectorOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::StepVectorOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value StepVectorOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ThreadLocalAddressOp> ThreadLocalAddressOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_THREADLOCAL_ADDRESS) {
-    return reinterpret_cast<const ThreadLocalAddressOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ThreadLocalAddressOp> ThreadLocalAddressOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::ThreadlocalAddressOp ThreadLocalAddressOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::ThreadlocalAddressOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ThreadLocalAddressOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<TrapOp> TrapOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_TRAP) {
-    return reinterpret_cast<const TrapOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TrapOp> TrapOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::Trap TrapOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::Trap(this->::mx::ir::Operation::op_);
-}
-
-std::optional<UAddSatOp> UAddSatOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_UADD_SAT) {
-    return reinterpret_cast<const UAddSatOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UAddSatOp> UAddSatOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UAddSat UAddSatOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UAddSat(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UAddSatOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UAddSatOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UAddSatOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UAddWithOverflowOp> UAddWithOverflowOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_UADD_WITH_OVERFLOW) {
-    return reinterpret_cast<const UAddWithOverflowOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UAddWithOverflowOp> UAddWithOverflowOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UAddWithOverflowOp UAddWithOverflowOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UAddWithOverflowOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UAddWithOverflowOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UBSanTrapOp> UBSanTrapOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_UBSANTRAP) {
-    return reinterpret_cast<const UBSanTrapOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UBSanTrapOp> UBSanTrapOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UBSanTrap UBSanTrapOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UBSanTrap(this->::mx::ir::Operation::op_);
-}
-
-uint8_t UBSanTrapOp::failure_kind(void) const {
-  auto val = underlying_repr().getFailureKind();
-  return val;
-}
-
-std::optional<UMaxOp> UMaxOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_UMAX) {
-    return reinterpret_cast<const UMaxOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UMaxOp> UMaxOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UMaxOp UMaxOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UMaxOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UMaxOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UMaxOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UMaxOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UMinOp> UMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_UMIN) {
-    return reinterpret_cast<const UMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UMinOp> UMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UMinOp UMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UMinOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UMinOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UMinOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UMulWithOverflowOp> UMulWithOverflowOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_UMUL_WITH_OVERFLOW) {
-    return reinterpret_cast<const UMulWithOverflowOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UMulWithOverflowOp> UMulWithOverflowOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::UMulWithOverflowOp UMulWithOverflowOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::UMulWithOverflowOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UMulWithOverflowOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UShlSatOp> UShlSatOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_USHL_SAT) {
-    return reinterpret_cast<const UShlSatOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UShlSatOp> UShlSatOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::USHLSat UShlSatOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::USHLSat(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UShlSatOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UShlSatOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value UShlSatOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<USubSatOp> USubSatOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_USUB_SAT) {
-    return reinterpret_cast<const USubSatOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<USubSatOp> USubSatOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::USubSat USubSatOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::USubSat(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value USubSatOp::a(void) const {
-  auto val = underlying_repr().getA();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value USubSatOp::b(void) const {
-  auto val = underlying_repr().getB();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value USubSatOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<USubWithOverflowOp> USubWithOverflowOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_USUB_WITH_OVERFLOW) {
-    return reinterpret_cast<const USubWithOverflowOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<USubWithOverflowOp> USubWithOverflowOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::USubWithOverflowOp USubWithOverflowOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::USubWithOverflowOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value USubWithOverflowOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPAShrOp> VPAShrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_ASHR) {
-    return reinterpret_cast<const VPAShrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPAShrOp> VPAShrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPAShrOp VPAShrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPAShrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPAShrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPAShrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPAShrOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPAShrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPAddOp> VPAddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_ADD) {
-    return reinterpret_cast<const VPAddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPAddOp> VPAddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPAddOp VPAddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPAddOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPAddOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPAddOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPAddOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPAddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPAndOp> VPAndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_AND) {
-    return reinterpret_cast<const VPAndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPAndOp> VPAndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPAndOp VPAndOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPAndOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPAndOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPAndOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPAndOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPAndOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFAddOp> VPFAddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FADD) {
-    return reinterpret_cast<const VPFAddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFAddOp> VPFAddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFAddOp VPFAddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFAddOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFAddOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFAddOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFAddOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFAddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFDivOp> VPFDivOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FDIV) {
-    return reinterpret_cast<const VPFDivOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFDivOp> VPFDivOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFDivOp VPFDivOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFDivOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFDivOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFDivOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFDivOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFDivOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFMulAddOp> VPFMulAddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FMULADD) {
-    return reinterpret_cast<const VPFMulAddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFMulAddOp> VPFMulAddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFMulAddOp VPFMulAddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFMulAddOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFMulAddOp::op1(void) const {
-  auto val = underlying_repr().getOp1();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFMulAddOp::op2(void) const {
-  auto val = underlying_repr().getOp2();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFMulAddOp::op3(void) const {
-  auto val = underlying_repr().getOp3();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFMulAddOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFMulAddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFMulOp> VPFMulOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FMUL) {
-    return reinterpret_cast<const VPFMulOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFMulOp> VPFMulOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFMulOp VPFMulOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFMulOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFMulOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFMulOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFMulOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFMulOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFNegOp> VPFNegOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FNEG) {
-    return reinterpret_cast<const VPFNegOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFNegOp> VPFNegOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFNegOp VPFNegOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFNegOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFNegOp::op(void) const {
-  auto val = underlying_repr().getOp();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFNegOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFNegOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFPExtOp> VPFPExtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FPEXT) {
-    return reinterpret_cast<const VPFPExtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFPExtOp> VPFPExtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFPExtOp VPFPExtOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFPExtOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFPExtOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFPExtOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFPExtOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFPToSIOp> VPFPToSIOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FPTOSI) {
-    return reinterpret_cast<const VPFPToSIOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFPToSIOp> VPFPToSIOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFPToSIOp VPFPToSIOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFPToSIOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFPToSIOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFPToSIOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFPToSIOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFPToUIOp> VPFPToUIOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FPTOUI) {
-    return reinterpret_cast<const VPFPToUIOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFPToUIOp> VPFPToUIOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFPToUIOp VPFPToUIOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFPToUIOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFPToUIOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFPToUIOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFPToUIOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFPTruncOp> VPFPTruncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FPTRUNC) {
-    return reinterpret_cast<const VPFPTruncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFPTruncOp> VPFPTruncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFPTruncOp VPFPTruncOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFPTruncOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFPTruncOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFPTruncOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFPTruncOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFRemOp> VPFRemOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FREM) {
-    return reinterpret_cast<const VPFRemOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFRemOp> VPFRemOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFRemOp VPFRemOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFRemOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFRemOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFRemOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFRemOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFRemOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFSubOp> VPFSubOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FSUB) {
-    return reinterpret_cast<const VPFSubOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFSubOp> VPFSubOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFSubOp VPFSubOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFSubOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFSubOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFSubOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFSubOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFSubOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPFmaOp> VPFmaOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_FMA) {
-    return reinterpret_cast<const VPFmaOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPFmaOp> VPFmaOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPFmaOp VPFmaOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPFmaOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPFmaOp::op1(void) const {
-  auto val = underlying_repr().getOp1();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFmaOp::op2(void) const {
-  auto val = underlying_repr().getOp2();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFmaOp::op3(void) const {
-  auto val = underlying_repr().getOp3();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFmaOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPFmaOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPIntToPtrOp> VPIntToPtrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_INTTOPTR) {
-    return reinterpret_cast<const VPIntToPtrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPIntToPtrOp> VPIntToPtrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPIntToPtrOp VPIntToPtrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPIntToPtrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPIntToPtrOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPIntToPtrOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPIntToPtrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPLShrOp> VPLShrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_LSHR) {
-    return reinterpret_cast<const VPLShrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPLShrOp> VPLShrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPLShrOp VPLShrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPLShrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPLShrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPLShrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPLShrOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPLShrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPLoadOp> VPLoadOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_LOAD) {
-    return reinterpret_cast<const VPLoadOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPLoadOp> VPLoadOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPLoadOp VPLoadOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPLoadOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPLoadOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPLoadOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPMergeMinOp> VPMergeMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_MERGE) {
-    return reinterpret_cast<const VPMergeMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPMergeMinOp> VPMergeMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPMergeMinOp VPMergeMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPMergeMinOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPMergeMinOp::cond(void) const {
-  auto val = underlying_repr().getCond();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPMergeMinOp::true_val(void) const {
-  auto val = underlying_repr().getTrueVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPMergeMinOp::false_val(void) const {
-  auto val = underlying_repr().getFalseVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPMergeMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPMulOp> VPMulOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_MUL) {
-    return reinterpret_cast<const VPMulOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPMulOp> VPMulOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPMulOp VPMulOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPMulOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPMulOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPMulOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPMulOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPMulOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPOrOp> VPOrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_OR) {
-    return reinterpret_cast<const VPOrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPOrOp> VPOrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPOrOp VPOrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPOrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPOrOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPOrOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPOrOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPOrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPPtrToIntOp> VPPtrToIntOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_PTRTOINT) {
-    return reinterpret_cast<const VPPtrToIntOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPPtrToIntOp> VPPtrToIntOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPPtrToIntOp VPPtrToIntOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPPtrToIntOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPPtrToIntOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPPtrToIntOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPPtrToIntOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceAddOp> VPReduceAddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_ADD) {
-    return reinterpret_cast<const VPReduceAddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceAddOp> VPReduceAddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceAddOp VPReduceAddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceAddOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceAddOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceAddOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceAddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceAndOp> VPReduceAndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_AND) {
-    return reinterpret_cast<const VPReduceAndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceAndOp> VPReduceAndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceAndOp VPReduceAndOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceAndOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceAndOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceAndOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceAndOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceFAddOp> VPReduceFAddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_FADD) {
-    return reinterpret_cast<const VPReduceFAddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceFAddOp> VPReduceFAddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceFAddOp VPReduceFAddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceFAddOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceFAddOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceFAddOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceFAddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceFMaxOp> VPReduceFMaxOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_FMAX) {
-    return reinterpret_cast<const VPReduceFMaxOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceFMaxOp> VPReduceFMaxOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceFMaxOp VPReduceFMaxOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceFMaxOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceFMaxOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceFMaxOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceFMaxOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceFMinOp> VPReduceFMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_FMIN) {
-    return reinterpret_cast<const VPReduceFMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceFMinOp> VPReduceFMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceFMinOp VPReduceFMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceFMinOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceFMinOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceFMinOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceFMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceFMulOp> VPReduceFMulOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_FMUL) {
-    return reinterpret_cast<const VPReduceFMulOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceFMulOp> VPReduceFMulOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceFMulOp VPReduceFMulOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceFMulOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceFMulOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceFMulOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceFMulOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceMulOp> VPReduceMulOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_MUL) {
-    return reinterpret_cast<const VPReduceMulOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceMulOp> VPReduceMulOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceMulOp VPReduceMulOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceMulOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceMulOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceMulOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceMulOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceOrOp> VPReduceOrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_OR) {
-    return reinterpret_cast<const VPReduceOrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceOrOp> VPReduceOrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceOrOp VPReduceOrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceOrOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceOrOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceOrOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceOrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceSMaxOp> VPReduceSMaxOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_SMAX) {
-    return reinterpret_cast<const VPReduceSMaxOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceSMaxOp> VPReduceSMaxOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceSMaxOp VPReduceSMaxOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceSMaxOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceSMaxOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceSMaxOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceSMaxOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceSMinOp> VPReduceSMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_SMIN) {
-    return reinterpret_cast<const VPReduceSMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceSMinOp> VPReduceSMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceSMinOp VPReduceSMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceSMinOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceSMinOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceSMinOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceSMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceUMaxOp> VPReduceUMaxOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_UMAX) {
-    return reinterpret_cast<const VPReduceUMaxOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceUMaxOp> VPReduceUMaxOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceUMaxOp VPReduceUMaxOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceUMaxOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceUMaxOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceUMaxOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceUMaxOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceUMinOp> VPReduceUMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_UMIN) {
-    return reinterpret_cast<const VPReduceUMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceUMinOp> VPReduceUMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceUMinOp VPReduceUMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceUMinOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceUMinOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceUMinOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceUMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPReduceXorOp> VPReduceXorOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_REDUCE_XOR) {
-    return reinterpret_cast<const VPReduceXorOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPReduceXorOp> VPReduceXorOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPReduceXorOp VPReduceXorOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPReduceXorOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPReduceXorOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceXorOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPReduceXorOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPSDivOp> VPSDivOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_SDIV) {
-    return reinterpret_cast<const VPSDivOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPSDivOp> VPSDivOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPSDivOp VPSDivOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPSDivOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPSDivOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSDivOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSDivOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSDivOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPSExtOp> VPSExtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_SEXT) {
-    return reinterpret_cast<const VPSExtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPSExtOp> VPSExtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPSExtOp VPSExtOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPSExtOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPSExtOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSExtOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSExtOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPSIToFPOp> VPSIToFPOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_SITOFP) {
-    return reinterpret_cast<const VPSIToFPOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPSIToFPOp> VPSIToFPOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPSIToFPOp VPSIToFPOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPSIToFPOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPSIToFPOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSIToFPOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSIToFPOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPSRemOp> VPSRemOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_SREM) {
-    return reinterpret_cast<const VPSRemOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPSRemOp> VPSRemOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPSRemOp VPSRemOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPSRemOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPSRemOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSRemOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSRemOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSRemOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPSelectMinOp> VPSelectMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_SELECT) {
-    return reinterpret_cast<const VPSelectMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPSelectMinOp> VPSelectMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPSelectMinOp VPSelectMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPSelectMinOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPSelectMinOp::cond(void) const {
-  auto val = underlying_repr().getCond();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSelectMinOp::true_val(void) const {
-  auto val = underlying_repr().getTrueVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSelectMinOp::false_val(void) const {
-  auto val = underlying_repr().getFalseVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSelectMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPShlOp> VPShlOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_SHL) {
-    return reinterpret_cast<const VPShlOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPShlOp> VPShlOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPShlOp VPShlOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPShlOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPShlOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPShlOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPShlOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPShlOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPStoreOp> VPStoreOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_STORE) {
-    return reinterpret_cast<const VPStoreOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPStoreOp> VPStoreOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPStoreOp VPStoreOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPStoreOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPStoreOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPStoreOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPStridedLoadOp> VPStridedLoadOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_LOAD) {
-    return reinterpret_cast<const VPStridedLoadOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPStridedLoadOp> VPStridedLoadOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPStridedLoadOp VPStridedLoadOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPStridedLoadOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPStridedLoadOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPStridedLoadOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPStridedStoreOp> VPStridedStoreOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_STORE) {
-    return reinterpret_cast<const VPStridedStoreOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPStridedStoreOp> VPStridedStoreOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPStridedStoreOp VPStridedStoreOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPStridedStoreOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPStridedStoreOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPStridedStoreOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPSubOp> VPSubOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_SUB) {
-    return reinterpret_cast<const VPSubOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPSubOp> VPSubOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPSubOp VPSubOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPSubOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPSubOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSubOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSubOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPSubOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPTruncOp> VPTruncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_TRUNC) {
-    return reinterpret_cast<const VPTruncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPTruncOp> VPTruncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPTruncOp VPTruncOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPTruncOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPTruncOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPTruncOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPTruncOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPUDivOp> VPUDivOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_UDIV) {
-    return reinterpret_cast<const VPUDivOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPUDivOp> VPUDivOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPUDivOp VPUDivOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPUDivOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPUDivOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPUDivOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPUDivOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPUDivOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPUIToFPOp> VPUIToFPOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_UITOFP) {
-    return reinterpret_cast<const VPUIToFPOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPUIToFPOp> VPUIToFPOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPUIToFPOp VPUIToFPOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPUIToFPOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPUIToFPOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPUIToFPOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPUIToFPOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPURemOp> VPURemOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_UREM) {
-    return reinterpret_cast<const VPURemOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPURemOp> VPURemOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPURemOp VPURemOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPURemOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPURemOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPURemOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPURemOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPURemOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPXorOp> VPXorOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_XOR) {
-    return reinterpret_cast<const VPXorOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPXorOp> VPXorOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPXorOp VPXorOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPXorOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPXorOp::left(void) const {
-  auto val = underlying_repr().getLhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPXorOp::right(void) const {
-  auto val = underlying_repr().getRhs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPXorOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPXorOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VPZExtOp> VPZExtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VP_ZEXT) {
-    return reinterpret_cast<const VPZExtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VPZExtOp> VPZExtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VPZExtOp VPZExtOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VPZExtOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VPZExtOp::source(void) const {
-  auto val = underlying_repr().getSrc();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPZExtOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VPZExtOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VaCopyOp> VaCopyOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VACOPY) {
-    return reinterpret_cast<const VaCopyOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VaCopyOp> VaCopyOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VaCopyOp VaCopyOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VaCopyOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<VaEndOp> VaEndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VAEND) {
-    return reinterpret_cast<const VaEndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VaEndOp> VaEndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VaEndOp VaEndOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VaEndOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<VaStartOp> VaStartOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VASTART) {
-    return reinterpret_cast<const VaStartOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VaStartOp> VaStartOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VaStartOp VaStartOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VaStartOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<VarAnnotationOp> VarAnnotationOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VAR_ANNOTATION) {
-    return reinterpret_cast<const VarAnnotationOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VarAnnotationOp> VarAnnotationOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::VarAnnotation VarAnnotationOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::VarAnnotation(this->::mx::ir::Operation::op_);
-}
-
-std::optional<MaskedCompressStoreOp> MaskedCompressStoreOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MASKED_COMPRESSSTORE) {
-    return reinterpret_cast<const MaskedCompressStoreOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MaskedCompressStoreOp> MaskedCompressStoreOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::masked_compressstore MaskedCompressStoreOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::masked_compressstore(this->::mx::ir::Operation::op_);
-}
-
-std::optional<MaskedExpandLoadOp> MaskedExpandLoadOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MASKED_EXPANDLOAD) {
-    return reinterpret_cast<const MaskedExpandLoadOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MaskedExpandLoadOp> MaskedExpandLoadOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::masked_expandload MaskedExpandLoadOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::masked_expandload(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MaskedExpandLoadOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<MaskedGatherOp> MaskedGatherOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MASKED_GATHER) {
-    return reinterpret_cast<const MaskedGatherOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MaskedGatherOp> MaskedGatherOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::masked_gather MaskedGatherOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::masked_gather(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MaskedGatherOp::ptrs(void) const {
-  auto val = underlying_repr().getPtrs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MaskedGatherOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> MaskedGatherOp::pass_thru(void) const & {
-  auto range = underlying_repr().getPassThru();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value MaskedGatherOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint32_t MaskedGatherOp::alignment(void) const {
-  auto val = underlying_repr().getAlignment();
-  return val;
-}
-
-std::optional<MaskedScatterOp> MaskedScatterOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_MASKED_SCATTER) {
-    return reinterpret_cast<const MaskedScatterOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MaskedScatterOp> MaskedScatterOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::masked_scatter MaskedScatterOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::masked_scatter(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value MaskedScatterOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MaskedScatterOp::ptrs(void) const {
-  auto val = underlying_repr().getPtrs();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value MaskedScatterOp::mask(void) const {
-  auto val = underlying_repr().getMask();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint32_t MaskedScatterOp::alignment(void) const {
-  auto val = underlying_repr().getAlignment();
-  return val;
-}
-
-std::optional<VectorExtractOp> VectorExtractOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_EXTRACT) {
-    return reinterpret_cast<const VectorExtractOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorExtractOp> VectorExtractOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_extract VectorExtractOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_extract(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorExtractOp::srcvec(void) const {
-  auto val = underlying_repr().getSrcvec();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorExtractOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint64_t VectorExtractOp::pos(void) const {
-  auto val = underlying_repr().getPos();
-  return val;
-}
-
-uint64_t VectorExtractOp::src_vector_bit_width(void) const {
-  auto val = underlying_repr().getSrcVectorBitWidth();
-  return val;
-}
-
-uint64_t VectorExtractOp::res_vector_bit_width(void) const {
-  auto val = underlying_repr().getResVectorBitWidth();
-  return val;
-}
-
-std::optional<VectorInsertOp> VectorInsertOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_INSERT) {
-    return reinterpret_cast<const VectorInsertOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorInsertOp> VectorInsertOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_insert VectorInsertOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_insert(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorInsertOp::dstvec(void) const {
-  auto val = underlying_repr().getDstvec();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorInsertOp::srcvec(void) const {
-  auto val = underlying_repr().getSrcvec();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorInsertOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint64_t VectorInsertOp::pos(void) const {
-  auto val = underlying_repr().getPos();
-  return val;
-}
-
-uint64_t VectorInsertOp::src_vector_bit_width(void) const {
-  auto val = underlying_repr().getSrcVectorBitWidth();
-  return val;
-}
-
-uint64_t VectorInsertOp::dst_vector_bit_width(void) const {
-  auto val = underlying_repr().getDstVectorBitWidth();
-  return val;
-}
-
-std::optional<VectorReduceAddOp> VectorReduceAddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_ADD) {
-    return reinterpret_cast<const VectorReduceAddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceAddOp> VectorReduceAddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_add VectorReduceAddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_add(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceAddOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceAddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceAndOp> VectorReduceAndOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_AND) {
-    return reinterpret_cast<const VectorReduceAndOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceAndOp> VectorReduceAndOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_and VectorReduceAndOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_and(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceAndOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceAndOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceFAddOp> VectorReduceFAddOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_FADD) {
-    return reinterpret_cast<const VectorReduceFAddOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceFAddOp> VectorReduceFAddOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_fadd VectorReduceFAddOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_fadd(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceFAddOp::input(void) const {
-  auto val = underlying_repr().getInput();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceFAddOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceFMaxOp> VectorReduceFMaxOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAX) {
-    return reinterpret_cast<const VectorReduceFMaxOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceFMaxOp> VectorReduceFMaxOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_fmax VectorReduceFMaxOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_fmax(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceFMaxOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceFMaxOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceFMaximumOp> VectorReduceFMaximumOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAXIMUM) {
-    return reinterpret_cast<const VectorReduceFMaximumOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceFMaximumOp> VectorReduceFMaximumOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_fmaximum VectorReduceFMaximumOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_fmaximum(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceFMaximumOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceFMaximumOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceFMinOp> VectorReduceFMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_FMIN) {
-    return reinterpret_cast<const VectorReduceFMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceFMinOp> VectorReduceFMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_fmin VectorReduceFMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_fmin(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceFMinOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceFMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceFMinimumOp> VectorReduceFMinimumOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_FMINIMUM) {
-    return reinterpret_cast<const VectorReduceFMinimumOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceFMinimumOp> VectorReduceFMinimumOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_fminimum VectorReduceFMinimumOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_fminimum(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceFMinimumOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceFMinimumOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceFMulOp> VectorReduceFMulOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_FMUL) {
-    return reinterpret_cast<const VectorReduceFMulOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceFMulOp> VectorReduceFMulOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_fmul VectorReduceFMulOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_fmul(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceFMulOp::input(void) const {
-  auto val = underlying_repr().getInput();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceFMulOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceMulOp> VectorReduceMulOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_MUL) {
-    return reinterpret_cast<const VectorReduceMulOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceMulOp> VectorReduceMulOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_mul VectorReduceMulOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_mul(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceMulOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceMulOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceOrOp> VectorReduceOrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_OR) {
-    return reinterpret_cast<const VectorReduceOrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceOrOp> VectorReduceOrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_or VectorReduceOrOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_or(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceOrOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceOrOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceSMaxOp> VectorReduceSMaxOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_SMAX) {
-    return reinterpret_cast<const VectorReduceSMaxOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceSMaxOp> VectorReduceSMaxOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_smax VectorReduceSMaxOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_smax(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceSMaxOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceSMaxOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceSMinOp> VectorReduceSMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_SMIN) {
-    return reinterpret_cast<const VectorReduceSMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceSMinOp> VectorReduceSMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_smin VectorReduceSMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_smin(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceSMinOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceSMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceUMaxOp> VectorReduceUMaxOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_UMAX) {
-    return reinterpret_cast<const VectorReduceUMaxOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceUMaxOp> VectorReduceUMaxOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_umax VectorReduceUMaxOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_umax(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceUMaxOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceUMaxOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceUMinOp> VectorReduceUMinOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_UMIN) {
-    return reinterpret_cast<const VectorReduceUMinOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceUMinOp> VectorReduceUMinOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_umin VectorReduceUMinOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_umin(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceUMinOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceUMinOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VectorReduceXorOp> VectorReduceXorOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VECTOR_REDUCE_XOR) {
-    return reinterpret_cast<const VectorReduceXorOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VectorReduceXorOp> VectorReduceXorOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vector_reduce_xor VectorReduceXorOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vector_reduce_xor(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VectorReduceXorOp::in(void) const {
-  auto val = underlying_repr().getIn();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value VectorReduceXorOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<VScaleOp> VScaleOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LLVM_INTR_VSCALE) {
-    return reinterpret_cast<const VScaleOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<VScaleOp> VScaleOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::vscale VScaleOp::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::vscale(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value VScaleOp::result(void) const {
-  auto val = underlying_repr().getRes();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-}  // namespace mx::ir::llvm
diff --git a/lib/IR/LLVM/Type.cpp b/lib/IR/LLVM/Type.cpp
deleted file mode 100644
index 3cfd3b0c1..000000000
--- a/lib/IR/LLVM/Type.cpp
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LLVM/Type.h>
-
-#include <multiplier/IR/Attribute.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-
-namespace mx::ir::llvm {
-std::optional<Type> Type::from(const ::mx::ir::Type &that) {
-  if (IsLLVMIRTypeKind(that.kind())) {
-    return reinterpret_cast<const Type &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ArrayType> ArrayType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::LLVM_ARRAY) {
-    return reinterpret_cast<const ArrayType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LLVMArrayType ArrayType::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LLVMArrayType(this->::mx::ir::Type::type_);
-}
-
-unsigned int ArrayType::num_elements(void) const {
-  auto val = underlying_repr().getNumElements();
-  return val;
-}
-
-std::optional<FunctionType> FunctionType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::LLVM_FUNCTION) {
-    return reinterpret_cast<const FunctionType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LLVMFunctionType FunctionType::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LLVMFunctionType(this->::mx::ir::Type::type_);
-}
-
-bool FunctionType::is_var_arg(void) const {
-  auto val = underlying_repr().isVarArg();
-  return val;
-}
-
-unsigned int FunctionType::num_params(void) const {
-  auto val = underlying_repr().getNumParams();
-  return val;
-}
-
-gap::generator<::mx::ir::Type> FunctionType::params(void) const & {
-  auto range = underlying_repr().getParams();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-bool FunctionType::var_arg(void) const {
-  auto val = underlying_repr().getVarArg();
-  return val;
-}
-
-std::optional<PointerType> PointerType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::LLVM_POINTER) {
-    return reinterpret_cast<const PointerType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LLVMPointerType PointerType::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LLVMPointerType(this->::mx::ir::Type::type_);
-}
-
-unsigned int PointerType::address_space(void) const {
-  auto val = underlying_repr().getAddressSpace();
-  return val;
-}
-
-std::optional<FixedVectorType> FixedVectorType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::LLVM_FIXED_VECTOR) {
-    return reinterpret_cast<const FixedVectorType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LLVMFixedVectorType FixedVectorType::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LLVMFixedVectorType(this->::mx::ir::Type::type_);
-}
-
-unsigned int FixedVectorType::num_elements(void) const {
-  auto val = underlying_repr().getNumElements();
-  return val;
-}
-
-std::optional<ScalableVectorType> ScalableVectorType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::LLVM_SCALABLE_VECTOR) {
-    return reinterpret_cast<const ScalableVectorType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LLVMScalableVectorType ScalableVectorType::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LLVMScalableVectorType(this->::mx::ir::Type::type_);
-}
-
-unsigned int ScalableVectorType::min_num_elements(void) const {
-  auto val = underlying_repr().getMinNumElements();
-  return val;
-}
-
-std::optional<TargetExtType> TargetExtType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::LLVM_TARGET_EXT) {
-    return reinterpret_cast<const TargetExtType &>(that);
-  }
-  return std::nullopt;
-}
-
-::mlir::LLVM::LLVMTargetExtType TargetExtType::underlying_repr(void) const noexcept {
-  return ::mlir::LLVM::LLVMTargetExtType(this->::mx::ir::Type::type_);
-}
-
-bool TargetExtType::supports_mem_ops(void) const {
-  auto val = underlying_repr().supportsMemOps();
-  return val;
-}
-
-std::string_view TargetExtType::ext_type_name(void) const {
-  auto val = underlying_repr().getExtTypeName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-gap::generator<::mx::ir::Type> TargetExtType::type_params(void) const & {
-  auto range = underlying_repr().getTypeParams();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-}  // namespace mx::ir::llvm
diff --git a/lib/IR/LowLevel/Operation.cpp b/lib/IR/LowLevel/Operation.cpp
deleted file mode 100644
index 7c9e4540a..000000000
--- a/lib/IR/LowLevel/Operation.cpp
+++ /dev/null
@@ -1,621 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/LowLevel/Operation.h>
-
-#include <multiplier/IR/Attribute.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Type.h>
-
-#include <ios>
-#include <string>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/ABI/ABIOps.hpp>
-#include <vast/Dialect/HighLevel/HighLevelOps.hpp>
-#include <vast/Dialect/LowLevel/LowLevelOps.hpp>
-
-namespace mx::ir::ll {
-std::optional<Operation> Operation::from(const ::mx::ir::Operation &that) {
-  if (IsLowLevelOperationKind(that.kind())) {
-    return reinterpret_cast<const Operation &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AllocaOp> AllocaOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_ALLOCA) {
-    return reinterpret_cast<const AllocaOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AllocaOp> AllocaOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::Alloca AllocaOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::Alloca(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AllocaOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<ArgAllocaOp> ArgAllocaOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_ARG_ALLOCA) {
-    return reinterpret_cast<const ArgAllocaOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ArgAllocaOp> ArgAllocaOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::ArgAlloca ArgAllocaOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::ArgAlloca(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ArgAllocaOp::fn_arg(void) const {
-  auto val = underlying_repr().getFnArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ArgAllocaOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<BrOp> BrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_BR) {
-    return reinterpret_cast<const BrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<BrOp> BrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::Br BrOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::Br(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> BrOp::operands(void) const & {
-  auto range = underlying_repr().getOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<ConcatOp> ConcatOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_CONCAT) {
-    return reinterpret_cast<const ConcatOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ConcatOp> ConcatOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::Concat ConcatOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::Concat(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> ConcatOp::arguments(void) const & {
-  auto range = underlying_repr().getArgs();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value ConcatOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CondBrOp> CondBrOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_COND_BR) {
-    return reinterpret_cast<const CondBrOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CondBrOp> CondBrOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::CondBr CondBrOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::CondBr(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CondBrOp::cond(void) const {
-  auto val = underlying_repr().getCond();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> CondBrOp::true_operands(void) const & {
-  auto range = underlying_repr().getTrueOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> CondBrOp::false_operands(void) const & {
-  auto range = underlying_repr().getFalseOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<CondScopeRetOp> CondScopeRetOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_COND_SCOPE_RET) {
-    return reinterpret_cast<const CondScopeRetOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CondScopeRetOp> CondScopeRetOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::CondScopeRet CondScopeRetOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::CondScopeRet(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value CondScopeRetOp::cond(void) const {
-  auto val = underlying_repr().getCond();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> CondScopeRetOp::dest_operands(void) const & {
-  auto range = underlying_repr().getDestOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<ExtractOp> ExtractOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_EXTRACT) {
-    return reinterpret_cast<const ExtractOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExtractOp> ExtractOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::Extract ExtractOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::Extract(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ExtractOp::argument(void) const {
-  auto val = underlying_repr().getArg();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value ExtractOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::size_t ExtractOp::size(void) const {
-  auto val = underlying_repr().size();
-  return val;
-}
-
-std::optional<InitializeVarOp> InitializeVarOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_INITIALIZE) {
-    return reinterpret_cast<const InitializeVarOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InitializeVarOp> InitializeVarOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::InitializeVar InitializeVarOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::InitializeVar(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value InitializeVarOp::var(void) const {
-  auto val = underlying_repr().getVar();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> InitializeVarOp::elements(void) const & {
-  auto range = underlying_repr().getElements();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value InitializeVarOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<InlineScopeOp> InlineScopeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_INLINE_SCOPE) {
-    return reinterpret_cast<const InlineScopeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<InlineScopeOp> InlineScopeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::InlineScope InlineScopeOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::InlineScope(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region InlineScopeOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<LoadOp> LoadOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_LOAD) {
-    return reinterpret_cast<const LoadOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LoadOp> LoadOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::Load LoadOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::Load(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value LoadOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<FuncOp> FuncOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_FUNC) {
-    return reinterpret_cast<const FuncOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<FuncOp> FuncOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::FuncOp FuncOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::FuncOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<::mx::ir::Region> FuncOp::body(void) const {
-  decltype(auto) opt_val = underlying_repr().getBody();
-  if (opt_val.empty()) {
-    return std::nullopt;
-  }
-  auto &val = opt_val;
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view FuncOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-::mx::ir::Type FuncOp::function_type(void) const {
-  auto mlir_type = underlying_repr().getFunctionType();
-  return ::mx::ir::Type(
-      mlir_type.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          mlir_type.getAsOpaquePointer()));
-}
-
-std::optional<std::string_view> FuncOp::visibility(void) const {
-  auto opt_val = underlying_repr().getSymVisibility();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool FuncOp::is_var_arg(void) const {
-  auto val = underlying_repr().isVarArg();
-  return val;
-}
-
-gap::generator<::mx::ir::Type> FuncOp::callable_results(void) const & {
-  auto range = underlying_repr().getCallableResults();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-gap::generator<::mx::ir::Type> FuncOp::argument_types(void) const & {
-  auto range = underlying_repr().getArgumentTypes();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-gap::generator<::mx::ir::Type> FuncOp::result_types(void) const & {
-  auto range = underlying_repr().getResultTypes();
-  for (auto el_ty : range) {
-    co_yield ::mx::ir::Type(
-        el_ty.getContext(),
-        reinterpret_cast<const mlir::TypeStorage *>(
-            el_ty.getAsOpaquePointer()));
-  }
-}
-
-bool FuncOp::is_declaration(void) const {
-  auto val = underlying_repr().isDeclaration();
-  return val;
-}
-
-std::optional<StructGEPOp> StructGEPOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_GEP) {
-    return reinterpret_cast<const StructGEPOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StructGEPOp> StructGEPOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::StructGEPOp StructGEPOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::StructGEPOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value StructGEPOp::record(void) const {
-  auto val = underlying_repr().getRecord();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value StructGEPOp::element(void) const {
-  auto val = underlying_repr().getElement();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-uint32_t StructGEPOp::idx(void) const {
-  auto val = underlying_repr().getIdx();
-  return val;
-}
-
-std::string_view StructGEPOp::field(void) const {
-  auto val = underlying_repr().getField();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<ReturnOp> ReturnOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_RETURN) {
-    return reinterpret_cast<const ReturnOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ReturnOp> ReturnOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::ReturnOp ReturnOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::ReturnOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> ReturnOp::result(void) const & {
-  auto range = underlying_repr().getResult();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<ScopeOp> ScopeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_SCOPE) {
-    return reinterpret_cast<const ScopeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ScopeOp> ScopeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::Scope ScopeOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::Scope(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region ScopeOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<ScopeRecurseOp> ScopeRecurseOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_SCOPE_RECURSE) {
-    return reinterpret_cast<const ScopeRecurseOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ScopeRecurseOp> ScopeRecurseOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::ScopeRecurse ScopeRecurseOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::ScopeRecurse(this->::mx::ir::Operation::op_);
-}
-
-std::optional<ScopeRetOp> ScopeRetOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_SCOPE_RET) {
-    return reinterpret_cast<const ScopeRetOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ScopeRetOp> ScopeRetOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::ScopeRet ScopeRetOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::ScopeRet(this->::mx::ir::Operation::op_);
-}
-
-std::optional<StoreOp> StoreOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_STORE) {
-    return reinterpret_cast<const StoreOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StoreOp> StoreOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::Store StoreOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::Store(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value StoreOp::value(void) const {
-  auto val = underlying_repr().getVal();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SubscriptOp> SubscriptOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_SUBSCRIPT) {
-    return reinterpret_cast<const SubscriptOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SubscriptOp> SubscriptOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::Subscript SubscriptOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::Subscript(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value SubscriptOp::array(void) const {
-  auto val = underlying_repr().getArray();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubscriptOp::index(void) const {
-  auto val = underlying_repr().getIndex();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Value SubscriptOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<UninitializedVarOp> UninitializedVarOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::LL_UNINITIALIZED_VAR) {
-    return reinterpret_cast<const UninitializedVarOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UninitializedVarOp> UninitializedVarOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::ll::UninitializedVar UninitializedVarOp::underlying_repr(void) const noexcept {
-  return ::vast::ll::UninitializedVar(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UninitializedVarOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-}  // namespace mx::ir::ll
diff --git a/lib/IR/MemRef/Operation.cpp b/lib/IR/MemRef/Operation.cpp
deleted file mode 100644
index f302c1586..000000000
--- a/lib/IR/MemRef/Operation.cpp
+++ /dev/null
@@ -1,1006 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/MemRef/Operation.h>
-
-#include <multiplier/IR/Attribute.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Type.h>
-
-#include <ios>
-#include <string>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <mlir/Dialect/MemRef/IR/MemRef.h>
-
-namespace mx::ir::memref {
-std::optional<Operation> Operation::from(const ::mx::ir::Operation &that) {
-  if (IsMemRefOperationKind(that.kind())) {
-    return reinterpret_cast<const Operation &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AssumeAlignmentOp> AssumeAlignmentOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_ASSUME_ALIGNMENT) {
-    return reinterpret_cast<const AssumeAlignmentOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AssumeAlignmentOp> AssumeAlignmentOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::AssumeAlignmentOp AssumeAlignmentOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::AssumeAlignmentOp(this->::mx::ir::Operation::op_);
-}
-
-uint32_t AssumeAlignmentOp::alignment(void) const {
-  auto val = underlying_repr().getAlignment();
-  return val;
-}
-
-std::optional<AtomicRMWOp> AtomicRMWOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_ATOMIC_RMW) {
-    return reinterpret_cast<const AtomicRMWOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AtomicRMWOp> AtomicRMWOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::AtomicRMWOp AtomicRMWOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::AtomicRMWOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AtomicRMWOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> AtomicRMWOp::indices(void) const & {
-  auto range = underlying_repr().getIndices();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value AtomicRMWOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<AtomicYieldOp> AtomicYieldOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_ATOMIC_YIELD) {
-    return reinterpret_cast<const AtomicYieldOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AtomicYieldOp> AtomicYieldOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::AtomicYieldOp AtomicYieldOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::AtomicYieldOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value AtomicYieldOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<CopyOp> CopyOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_COPY) {
-    return reinterpret_cast<const CopyOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CopyOp> CopyOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::CopyOp CopyOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::CopyOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<GenericAtomicRMWOp> GenericAtomicRMWOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_GENERIC_ATOMIC_RMW) {
-    return reinterpret_cast<const GenericAtomicRMWOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GenericAtomicRMWOp> GenericAtomicRMWOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::GenericAtomicRMWOp GenericAtomicRMWOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::GenericAtomicRMWOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> GenericAtomicRMWOp::indices(void) const & {
-  auto range = underlying_repr().getIndices();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value GenericAtomicRMWOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-::mx::ir::Region GenericAtomicRMWOp::atomic_body(void) const {
-  auto &val = underlying_repr().getAtomicBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<LoadOp> LoadOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_LOAD) {
-    return reinterpret_cast<const LoadOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<LoadOp> LoadOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::LoadOp LoadOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::LoadOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> LoadOp::indices(void) const & {
-  auto range = underlying_repr().getIndices();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value LoadOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-bool LoadOp::nontemporal(void) const {
-  auto val = underlying_repr().getNontemporal();
-  return val;
-}
-
-std::optional<AllocOp> AllocOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_ALLOC) {
-    return reinterpret_cast<const AllocOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AllocOp> AllocOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::AllocOp AllocOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::AllocOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> AllocOp::dynamic_sizes(void) const & {
-  auto range = underlying_repr().getDynamicSizes();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> AllocOp::symbol_operands(void) const & {
-  auto range = underlying_repr().getSymbolOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<unsigned long long> AllocOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<AllocaOp> AllocaOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_ALLOCA) {
-    return reinterpret_cast<const AllocaOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AllocaOp> AllocaOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::AllocaOp AllocaOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::AllocaOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> AllocaOp::dynamic_sizes(void) const & {
-  auto range = underlying_repr().getDynamicSizes();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> AllocaOp::symbol_operands(void) const & {
-  auto range = underlying_repr().getSymbolOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<unsigned long long> AllocaOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<AllocaScopeOp> AllocaScopeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_ALLOCA_SCOPE) {
-    return reinterpret_cast<const AllocaScopeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AllocaScopeOp> AllocaScopeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::AllocaScopeOp AllocaScopeOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::AllocaScopeOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Result> AllocaScopeOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Region AllocaScopeOp::body_region(void) const {
-  auto &val = underlying_repr().getBodyRegion();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::optional<AllocaScopeReturnOp> AllocaScopeReturnOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_ALLOCA_SCOPE_RETURN) {
-    return reinterpret_cast<const AllocaScopeReturnOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<AllocaScopeReturnOp> AllocaScopeReturnOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::AllocaScopeReturnOp AllocaScopeReturnOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::AllocaScopeReturnOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> AllocaScopeReturnOp::results(void) const & {
-  auto range = underlying_repr().getResults();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-std::optional<CastOp> CastOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_CAST) {
-    return reinterpret_cast<const CastOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CastOp> CastOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::CastOp CastOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::CastOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<CollapseShapeOp> CollapseShapeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_COLLAPSE_SHAPE) {
-    return reinterpret_cast<const CollapseShapeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<CollapseShapeOp> CollapseShapeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::CollapseShapeOp CollapseShapeOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::CollapseShapeOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<DeallocOp> DeallocOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_DEALLOC) {
-    return reinterpret_cast<const DeallocOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DeallocOp> DeallocOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::DeallocOp DeallocOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::DeallocOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<DimOp> DimOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_DIM) {
-    return reinterpret_cast<const DimOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DimOp> DimOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::DimOp DimOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::DimOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value DimOp::source(void) const {
-  auto val = underlying_repr().getSource();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<long long> DimOp::constant_index(void) const {
-  auto opt_val = underlying_repr().getConstantIndex();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<DMAStartOp> DMAStartOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_DMA_START) {
-    return reinterpret_cast<const DMAStartOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DMAStartOp> DMAStartOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::DmaStartOp DMAStartOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::DmaStartOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> DMAStartOp::operands(void) const & {
-  auto range = underlying_repr().getOperands();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-unsigned int DMAStartOp::src_mem_ref_rank(void) const {
-  auto val = underlying_repr().getSrcMemRefRank();
-  return val;
-}
-
-unsigned int DMAStartOp::dst_mem_ref_rank(void) const {
-  auto val = underlying_repr().getDstMemRefRank();
-  return val;
-}
-
-unsigned int DMAStartOp::src_memory_space(void) const {
-  auto val = underlying_repr().getSrcMemorySpace();
-  return val;
-}
-
-unsigned int DMAStartOp::dst_memory_space(void) const {
-  auto val = underlying_repr().getDstMemorySpace();
-  return val;
-}
-
-unsigned int DMAStartOp::tag_mem_ref_rank(void) const {
-  auto val = underlying_repr().getTagMemRefRank();
-  return val;
-}
-
-bool DMAStartOp::is_dest_memory_space_faster(void) const {
-  auto val = underlying_repr().isDestMemorySpaceFaster();
-  return val;
-}
-
-bool DMAStartOp::is_src_memory_space_faster(void) const {
-  auto val = underlying_repr().isSrcMemorySpaceFaster();
-  return val;
-}
-
-unsigned int DMAStartOp::faster_mem_pos(void) const {
-  auto val = underlying_repr().getFasterMemPos();
-  return val;
-}
-
-bool DMAStartOp::is_strided(void) const {
-  auto val = underlying_repr().isStrided();
-  return val;
-}
-
-std::optional<DMAWaitOp> DMAWaitOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_DMA_WAIT) {
-    return reinterpret_cast<const DMAWaitOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<DMAWaitOp> DMAWaitOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::DmaWaitOp DMAWaitOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::DmaWaitOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> DMAWaitOp::tag_indices(void) const & {
-  auto range = underlying_repr().getTagIndices();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-unsigned int DMAWaitOp::tag_mem_ref_rank(void) const {
-  auto val = underlying_repr().getTagMemRefRank();
-  return val;
-}
-
-std::optional<ExpandShapeOp> ExpandShapeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_EXPAND_SHAPE) {
-    return reinterpret_cast<const ExpandShapeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExpandShapeOp> ExpandShapeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::ExpandShapeOp ExpandShapeOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::ExpandShapeOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<ExtractAlignedPointerAsIndexOp> ExtractAlignedPointerAsIndexOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_EXTRACT_ALIGNED_POINTER_AS_INDEX) {
-    return reinterpret_cast<const ExtractAlignedPointerAsIndexOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExtractAlignedPointerAsIndexOp> ExtractAlignedPointerAsIndexOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::ExtractAlignedPointerAsIndexOp ExtractAlignedPointerAsIndexOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::ExtractAlignedPointerAsIndexOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<ExtractStridedMetadataOp> ExtractStridedMetadataOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_EXTRACT_STRIDED_METADATA) {
-    return reinterpret_cast<const ExtractStridedMetadataOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ExtractStridedMetadataOp> ExtractStridedMetadataOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::ExtractStridedMetadataOp ExtractStridedMetadataOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::ExtractStridedMetadataOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value ExtractStridedMetadataOp::base_buffer(void) const {
-  auto val = underlying_repr().getBaseBuffer();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Result> ExtractStridedMetadataOp::sizes(void) const & {
-  auto range = underlying_repr().getSizes();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Result> ExtractStridedMetadataOp::strides(void) const & {
-  auto range = underlying_repr().getStrides();
-  for (auto val : range) {
-    co_yield ::mx::ir::Result(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value ExtractStridedMetadataOp::view_source(void) const {
-  auto val = underlying_repr().getViewSource();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<GetGlobalOp> GetGlobalOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_GET_GLOBAL) {
-    return reinterpret_cast<const GetGlobalOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GetGlobalOp> GetGlobalOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::GetGlobalOp GetGlobalOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::GetGlobalOp(this->::mx::ir::Operation::op_);
-}
-
-std::string_view GetGlobalOp::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<GlobalOp> GlobalOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_GLOBAL) {
-    return reinterpret_cast<const GlobalOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<GlobalOp> GlobalOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::GlobalOp GlobalOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::GlobalOp(this->::mx::ir::Operation::op_);
-}
-
-std::string_view GlobalOp::name(void) const {
-  auto val = underlying_repr().getSymName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<std::string_view> GlobalOp::visibility(void) const {
-  auto opt_val = underlying_repr().getSymVisibility();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-bool GlobalOp::constant(void) const {
-  auto val = underlying_repr().getConstant();
-  return val;
-}
-
-std::optional<unsigned long long> GlobalOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-bool GlobalOp::is_external(void) const {
-  auto val = underlying_repr().isExternal();
-  return val;
-}
-
-bool GlobalOp::is_uninitialized(void) const {
-  auto val = underlying_repr().isUninitialized();
-  return val;
-}
-
-std::optional<MemorySpaceCastOp> MemorySpaceCastOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_MEMORY_SPACE_CAST) {
-    return reinterpret_cast<const MemorySpaceCastOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<MemorySpaceCastOp> MemorySpaceCastOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::MemorySpaceCastOp MemorySpaceCastOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::MemorySpaceCastOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<PrefetchOp> PrefetchOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_PREFETCH) {
-    return reinterpret_cast<const PrefetchOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<PrefetchOp> PrefetchOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::PrefetchOp PrefetchOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::PrefetchOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> PrefetchOp::indices(void) const & {
-  auto range = underlying_repr().getIndices();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-bool PrefetchOp::is_write(void) const {
-  auto val = underlying_repr().getIsWrite();
-  return val;
-}
-
-uint32_t PrefetchOp::locality_hint(void) const {
-  auto val = underlying_repr().getLocalityHint();
-  return val;
-}
-
-bool PrefetchOp::is_data_cache(void) const {
-  auto val = underlying_repr().getIsDataCache();
-  return val;
-}
-
-std::optional<RankOp> RankOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_RANK) {
-    return reinterpret_cast<const RankOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<RankOp> RankOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::RankOp RankOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::RankOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<ReallocOp> ReallocOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_REALLOC) {
-    return reinterpret_cast<const ReallocOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ReallocOp> ReallocOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::ReallocOp ReallocOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::ReallocOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<unsigned long long> ReallocOp::alignment(void) const {
-  auto opt_val = underlying_repr().getAlignment();
-  if (!opt_val) {
-    return std::nullopt;
-  }
-  auto &val = opt_val.value();
-  return val;
-}
-
-std::optional<ReinterpretCastOp> ReinterpretCastOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_REINTERPRET_CAST) {
-    return reinterpret_cast<const ReinterpretCastOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ReinterpretCastOp> ReinterpretCastOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::ReinterpretCastOp ReinterpretCastOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::ReinterpretCastOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> ReinterpretCastOp::offsets(void) const & {
-  auto range = underlying_repr().getOffsets();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> ReinterpretCastOp::sizes(void) const & {
-  auto range = underlying_repr().getSizes();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> ReinterpretCastOp::strides(void) const & {
-  auto range = underlying_repr().getStrides();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> ReinterpretCastOp::dynamic_sizes(void) const & {
-  auto range = underlying_repr().getDynamicSizes();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-unsigned int ReinterpretCastOp::result_rank(void) const {
-  auto val = underlying_repr().getResultRank();
-  return val;
-}
-
-unsigned int ReinterpretCastOp::offset_size_and_stride_start_operand_index(void) const {
-  auto val = underlying_repr().getOffsetSizeAndStrideStartOperandIndex();
-  return val;
-}
-
-std::optional<ReshapeOp> ReshapeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_RESHAPE) {
-    return reinterpret_cast<const ReshapeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ReshapeOp> ReshapeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::ReshapeOp ReshapeOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::ReshapeOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<StoreOp> StoreOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_STORE) {
-    return reinterpret_cast<const StoreOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<StoreOp> StoreOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::StoreOp StoreOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::StoreOp(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value StoreOp::value(void) const {
-  auto val = underlying_repr().getValue();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> StoreOp::indices(void) const & {
-  auto range = underlying_repr().getIndices();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-bool StoreOp::nontemporal(void) const {
-  auto val = underlying_repr().getNontemporal();
-  return val;
-}
-
-std::optional<TransposeOp> TransposeOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_TRANSPOSE) {
-    return reinterpret_cast<const TransposeOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<TransposeOp> TransposeOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::TransposeOp TransposeOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::TransposeOp(this->::mx::ir::Operation::op_);
-}
-
-std::optional<ViewOp> ViewOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_VIEW) {
-    return reinterpret_cast<const ViewOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<ViewOp> ViewOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::ViewOp ViewOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::ViewOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> ViewOp::sizes(void) const & {
-  auto range = underlying_repr().getSizes();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value ViewOp::view_source(void) const {
-  auto val = underlying_repr().getViewSource();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-std::optional<SubViewOp> SubViewOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::MEMREF_SUBVIEW) {
-    return reinterpret_cast<const SubViewOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<SubViewOp> SubViewOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::mlir::memref::SubViewOp SubViewOp::underlying_repr(void) const noexcept {
-  return ::mlir::memref::SubViewOp(this->::mx::ir::Operation::op_);
-}
-
-gap::generator<::mx::ir::Operand> SubViewOp::offsets(void) const & {
-  auto range = underlying_repr().getOffsets();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> SubViewOp::sizes(void) const & {
-  auto range = underlying_repr().getSizes();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-gap::generator<::mx::ir::Operand> SubViewOp::strides(void) const & {
-  auto range = underlying_repr().getStrides();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-::mx::ir::Value SubViewOp::view_source(void) const {
-  auto val = underlying_repr().getViewSource();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Operand> SubViewOp::dynamic_sizes(void) const & {
-  auto range = underlying_repr().getDynamicSizes();
-  for (auto val : range) {
-    co_yield ::mx::ir::Operand(module_, val.getAsOpaquePointer());
-  }
-}
-
-unsigned int SubViewOp::offset_size_and_stride_start_operand_index(void) const {
-  auto val = underlying_repr().getOffsetSizeAndStrideStartOperandIndex();
-  return val;
-}
-
-}  // namespace mx::ir::memref
diff --git a/lib/IR/Meta/Attribute.cpp b/lib/IR/Meta/Attribute.cpp
deleted file mode 100644
index 6af5221ce..000000000
--- a/lib/IR/Meta/Attribute.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Meta/Attribute.h>
-
-#include <multiplier/IR/Type.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/Meta/MetaAttributes.hpp>
-
-namespace mx::ir::meta {
-std::optional<Attribute> Attribute::from(const ::mx::ir::Attribute &that) {
-  if (IsMetaAttributeKind(that.kind())) {
-    return reinterpret_cast<const Attribute &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<IdentifierAttr> IdentifierAttr::from(const ::mx::ir::Attribute &that) {
-  if (that.kind() == AttributeKind::META_IDENTIFIER) {
-    return reinterpret_cast<const IdentifierAttr &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::meta::IdentifierAttr IdentifierAttr::underlying_repr(void) const noexcept {
-  return ::vast::meta::IdentifierAttr(this->::mx::ir::Attribute::attr_);
-}
-
-}  // namespace mx::ir::meta
diff --git a/lib/IR/Operation.cpp b/lib/IR/Operation.cpp
deleted file mode 100644
index 3a42c1422..000000000
--- a/lib/IR/Operation.cpp
+++ /dev/null
@@ -1,421 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#include <multiplier/IR/Operation.h>
-
-#include <cassert>
-#include <mlir/IR/Block.h>
-#include <mlir/IR/Operation.h>
-#include <mlir/IR/OperationSupport.h>
-#include <mlir/IR/Region.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/HighLevel/Operation.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Value.h>
-#include <unordered_map>
-#include <vast/Util/Symbols.hpp>
-#include <vast/Util/Terminator.hpp>
-
-#include "Operation.h"
-
-namespace mx::ir {
-namespace {
-
-static const std::string_view kEmptySymbolName("");
-
-}  // namespace
-
-bool OperationIdsMatch(mlir::Operation *a, mlir::Operation *b) {
-  auto a_eid = a->getLoc().cast<mlir::OpaqueLoc>().getUnderlyingLocation();
-  auto b_eid = b->getLoc().cast<mlir::OpaqueLoc>().getUnderlyingLocation();
-  if (a_eid != b_eid) {
-    return false;
-  }
-
-  return a_eid != kInvalidEntityId;
-}
-
-Operation::Operation(std::shared_ptr<const SourceIRImpl> module,
-                     mlir::Operation *opaque,
-                     OperationKind kind)
-    : module_(std::move(module)),
-      op_(opaque),
-      kind_(kind) {
-  assert(op_ != nullptr);        
-}
-
-// Return the ID of this operation.
-EntityId Operation::id(void) const noexcept {
-  auto eid = op_->getLoc().cast<mlir::OpaqueLoc>().getUnderlyingLocation();
-  return EntityId(eid).Extract<::mx::OperationId>().value();
-}
-
-bool Operation::operator==(const Operation &that) const noexcept {
-  if (underlying_operation() == that.underlying_operation()) {
-    return true;
-  }
-
-  if (module_ == that.module_) {
-    return false;
-  }
-
-  return OperationIdsMatch(op_, that.op_);
-}
-
-std::string_view Operation::kind_name(void) const noexcept {
-  switch (kind_) {
-    case OperationKind::UNKNOWN: break;
-#define MAP_OP_NAME(name, kind, type) \
-    case kind: return name;
-
-  MX_IR_FOR_EACH_MLIR_OP(MAP_OP_NAME, MAP_OP_NAME, MAP_OP_NAME, MAP_OP_NAME,
-                         MAP_OP_NAME, MAP_OP_NAME, MAP_OP_NAME, MAP_OP_NAME,
-                         MAP_OP_NAME)
-#undef MAP_OP_NAME
-  }
-
-  // Fall back on the actual operation name, as given by MLIR.
-  llvm::StringRef name = op_->getName().getStringRef();
-  return std::string_view(name.data(), name.size());
-}
-
-std::optional<Operation> Operation::producing(const Value &val) {
-  if (mlir::Operation *op = mlir::Value(val.impl_.value).getDefiningOp()) {
-    return Operation(val.module_, op);
-  } else {
-    return std::nullopt;
-  }
-}
-
-Operation Operation::containing(const Region &region) {
-  return Operation(region.module_, region.region_->getParentOp());
-}
-
-Operation Operation::containing(const Block &block) {
-  return Operation(block.module_, block.block_->getParentOp());
-}
-
-// Operations can have zero or more operands.
-unsigned Operation::num_operands(void) const noexcept {
-  return op_->getNumOperands();
-}
-
-std::optional<Operand> Operation::nth_operand(unsigned i) const noexcept {
-  if (i < op_->getNumOperands()) {
-    mlir::OpOperand &op = op_->getOpOperands()[i];
-    return Operand(module_, &op);
-  }
-  return std::nullopt;
-}
-
-gap::generator<Operand> Operation::operands(void) const & noexcept {
-  for (mlir::OpOperand &op : op_->getOpOperands()) {
-    co_yield Operand(module_, &op);
-  }
-}
-
-unsigned Operation::num_results(void) const noexcept {
-  return op_->getNumResults();
-}
-
-std::optional<Result> Operation::nth_result(unsigned i) const noexcept {
-  if (i < op_->getNumResults()) {
-    return Result(module_,
-                  reinterpret_cast<mlir::detail::OpResultImpl *>(
-                      mlir::OpResult(op_->getResult(i)).getAsOpaquePointer()));
-  }
-  return std::nullopt;
-}
-
-gap::generator<Result> Operation::results(void) const & noexcept {
-  for (mlir::OpResult res : op_->getResults()) {
-    co_yield Result(module_,
-                    reinterpret_cast<mlir::detail::OpResultImpl *>(
-                        res.getAsOpaquePointer()));
-  }
-}
-
-// Operations can have zero or more nested regions. Regions allow one to
-// model sequential control-flow and concurrent data-flow graphs of
-// computation.
-unsigned Operation::num_regions(void) const noexcept {
-  return op_->getNumRegions();
-}
-
-std::optional<Region> Operation::nth_region(unsigned i) const noexcept {
-  if (i < op_->getNumRegions()) {
-    mlir::Region &region = op_->getRegion(i);
-    return Region(module_, &region);
-  }
-  return std::nullopt;
-}
-
-gap::generator<Region> Operation::regions(void) const & noexcept {
-  for (mlir::Region &region : op_->getRegions()) {
-    co_yield Region(module_, &region);
-  }
-}
-
-// If an operation has only one region, the return that region.
-std::optional<Region> Operation::only_region(void) const noexcept {
-  if (1u == op_->getNumRegions()) {
-    mlir::Region &region = op_->getRegion(0u);
-    return Region(module_, &region);
-  }
-  return std::nullopt;
-}
-
-// If an operation has only one region, then visit those blocks.
-gap::generator<Block> Operation::only_region_blocks(void) const & noexcept {
-  if (1u == op_->getNumRegions()) {
-    mlir::Region &region = op_->getRegion(0u);
-    for (mlir::Block &block : region.getBlocks()) {
-      co_yield Block(module_, &block);
-    }
-  }
-}
-
-gap::generator<Operand> Operation::uses(void) const & noexcept {
-  for (mlir::OpResult res : op_->getResults()) {
-    for (mlir::OpOperand &use : res.getUses()) {
-      co_yield Operand(module_, &use);
-    }
-  }
-}
-
-// Returns `true` whether or not this operation is a terminator.
-bool Operation::is_terminator(void) const noexcept {
-  return vast::is_terminator(op_) ||
-         vast::core::is_soft_terminator(op_);
-}
-
-// Return the previous and next operations in the current `Block`.
-std::optional<Operation> Operation::previous(void) const noexcept {
-  if (auto prev_op = op_->getNextNode()) {
-    return Operation(module_, prev_op);
-  }
-  return std::nullopt;
-}
-
-std::optional<Operation> Operation::next(void) const noexcept {
-  if (auto next_op = op_->getNextNode()) {
-    return Operation(module_, next_op);
-  }
-  return std::nullopt;
-}
-
-// Return the name of this operation's symbol, if any.
-std::optional<Symbol> Operation::defined_symbol(void) const noexcept {
-  if (mlir::dyn_cast<vast::util::vast_symbol_interface>(op_)) {
-    return Symbol(module_, op_, kind_);
-  }
-
-  if (mlir::dyn_cast<vast::util::mlir_symbol_interface>(op_)) {
-    return Symbol(module_, op_, kind_);
-  }
-
-  return std::nullopt;
-}
-
-// Return the operation defining a symbol.
-Operation Operation::defining(const Symbol &symbol) {
-  return symbol.operation();
-}
-
-// Dump this operation.
-void Operation::dump(void) const {
-  return op_->dump();
-}
-
-// If an operation defines a symbol then return it.
-std::optional<Symbol> Symbol::from(const Operation &op) {
-  return op.defined_symbol();
-}
-
-// The operation defining this symbol.
-Operation Symbol::operation(void) const noexcept {
-  return Operation(module_, op_, kind_);
-}
-
-namespace hl {
-
-std::optional<RefOp> RefOp::from(const ::mx::ir::Operation &op) {
-  switch (op.kind()) {
-    case OperationKind::HL_REF:
-    case OperationKind::HL_FUNCREF:
-    case OperationKind::HL_GLOBREF:
-    case OperationKind::HL_ENUMREF:
-      return reinterpret_cast<const RefOp &>(op);
-    default:
-      return std::nullopt;
-  }
-}
-
-std::optional<Symbol> RefOp::referenced_symbol(void) const noexcept {
-
-  // if (mlir::isa<vast::hl::DeclRefOp>(uop) ||
-  //     mlir::isa<vast::hl::FuncRefOp>(uop) ||
-  //     mlir::isa<vast::hl::GlobalRefOp>(uop) ||
-  //     mlir::isa<vast::hl::EnumRefOp>(uop)) {
-  //   return RefOp();
-  // }
-
-  switch (kind()) {
-    case OperationKind::HL_REF: {
-      auto decl_ref = reinterpret_cast<const DeclRefOp &>(*this);
-      if (auto op = Operation::producing(decl_ref.declaration())) {
-        return op->defined_symbol();
-      }
-      break;
-    }
-    case OperationKind::HL_FUNCREF:
-      if (auto func_ref = mlir::dyn_cast<vast::hl::FuncRefOp>(op_)) {
-        (void) func_ref;
-      }
-      break;
-    case OperationKind::HL_GLOBREF:
-      if (auto global_ref = mlir::dyn_cast<vast::hl::GlobalRefOp>(op_)) {
-        (void) global_ref;
-      }
-      break;
-    case OperationKind::HL_ENUMREF:
-      if (auto enum_ref = mlir::dyn_cast<vast::hl::EnumRefOp>(op_)) {
-        (void) enum_ref;
-      }
-      break;
-    default:
-      break;
-  }
-  return std::nullopt;
-}
-
-}  // namespace hl
-
-// References to this symbol.
-gap::generator<Operation> Symbol::references(void) const & noexcept {
-  if (auto vast_symbol = mlir::dyn_cast<vast::util::vast_symbol_interface>(op_)) {
-    for (auto user : vast_symbol->getUsers()) {
-      co_yield Operation(module_, user);
-    }
-
-  } else if (auto mlir_symbol = mlir::dyn_cast<vast::util::mlir_symbol_interface >(op_)) {
-    auto stab = mlir::SymbolTable::getNearestSymbolTable(op_);
-    if (auto users = mlir_symbol.getSymbolUses(stab)) {
-      for (auto use : *users) {
-        co_yield Operation(module_, use.getUser());
-      }
-    }
-
-  } else {
-    co_return;
-  }
-}
-
-// Name of this symbol.
-std::string_view Symbol::name(void) const noexcept {
-  if (auto vast_symbol = mlir::dyn_cast<vast::util::vast_symbol_interface>(op_)) {
-    auto name = vast::util::symbol_name(vast_symbol);
-    return std::string_view(name.data(), name.size());
-  }
-
-  if (auto mlir_symbol = mlir::dyn_cast<vast::util::mlir_symbol_interface>(op_)) {
-    auto name = vast::util::symbol_name(mlir_symbol);
-    return std::string_view(name.data(), name.size());
-  }
-
-  assert(false);
-  return kEmptySymbolName;
-}
-
-bool Symbol::operator==(const Symbol &that) const noexcept {
-  if (underlying_operation() == that.underlying_operation()) {
-    return true;
-  }
-
-  if (module_ == that.module_) {
-    return false;
-  }
-
-  return OperationIdsMatch(op_, that.op_);
-}
-
-// If an operation produces a single result, then this gives us the result.
-std::optional<Result> Result::of(const Operation &op) {
-  if (op.op_->getNumResults() == 1u) {
-    return Result(op.module_,
-                  reinterpret_cast<mlir::detail::OpResultImpl *>(
-                      op.op_->getResult(0u).getAsOpaquePointer()));
-  }
-  return std::nullopt;
-}
-
-// Try to down-cast a `Value` to a `Result`.
-std::optional<Result> Result::from(const Value &val) {
-  if (mlir::Value(val.impl_.value).isa<mlir::OpResult>()) {
-    return Result(val.module_, val.impl_.result);
-  }
-  return std::nullopt;
-}
-
-// Return the operation producing this result.
-Operation Result::operation(void) const noexcept {
-  return Operation(module_, mlir::OpResult(impl_.result).getDefiningOp());
-}
-
-// Index of this result in its operation's result list.
-unsigned Result::index(void) const noexcept {
-  return mlir::OpResult(impl_.result).getResultNumber();
-}
-
-bool Result::operator==(const Result &that) const noexcept {
-  if (underlying_value() == that.underlying_value()) {
-    return true;
-  }
-
-  if (module_ == that.module_) {
-    return false;
-  }
-
-  if (index() != that.index()) {
-    return false;
-  }
-
-  return OperationIdsMatch(mlir::OpResult(impl_.result).getDefiningOp(),
-                           mlir::OpResult(that.impl_.result).getDefiningOp());
-}
-
-// The operation containing this operand.
-Operation Operand::operation(void) const noexcept {
-  return Operation(module_, op_->getOwner());
-}
-
-// The index of this operand within its owner operation's operand list.
-unsigned Operand::index(void) const noexcept {
-  return op_->getOperandNumber();
-}
-
-// Value associated with this operand. This could be a block argument, or
-// the result of another operation.
-Value Operand::value(void) const noexcept {
-  return Value(module_, op_->get().getAsOpaquePointer());
-}
-
-bool Operand::operator==(const Operand &that) const noexcept {
-  if (underlying_operand() == that.underlying_operand()) {
-    return true;
-  }
-
-  if (module_ == that.module_) {
-    return false;
-  }
-
-  if (index() != that.index()) {
-    return false;
-  }
-
-  return OperationIdsMatch(op_->getOwner(), that.op_->getOwner());
-}
-
-}  // namespace mx::ir
diff --git a/lib/IR/Operation.h b/lib/IR/Operation.h
deleted file mode 100644
index d1caf8dfa..000000000
--- a/lib/IR/Operation.h
+++ /dev/null
@@ -1,461 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#define MX_IR_FOR_EACH_MLIR_OP(_builtin, _llvm, _memref, _abi, _ll, _hl, _core, _meta, _unsup) \
-   _builtin("builtin.module", OperationKind::BUILTIN_MODULE, mlir::ModuleOp) \
-   _builtin("builtin.unrealized_conversion_cast", OperationKind::BUILTIN_UNREALIZED_CONVERSION_CAST, mlir::UnrealizedConversionCastOp) \
-   _llvm("llvm.ashr", OperationKind::LLVM_ASHR, mlir::LLVM::AShrOp) \
-   _llvm("llvm.add", OperationKind::LLVM_ADD, mlir::LLVM::AddOp) \
-   _llvm("llvm.addrspacecast", OperationKind::LLVM_ADDRSPACECAST, mlir::LLVM::AddrSpaceCastOp) \
-   _llvm("llvm.mlir.addressof", OperationKind::LLVM_MLIR_ADDRESSOF, mlir::LLVM::AddressOfOp) \
-   _llvm("llvm.alloca", OperationKind::LLVM_ALLOCA, mlir::LLVM::AllocaOp) \
-   _llvm("llvm.and", OperationKind::LLVM_AND, mlir::LLVM::AndOp) \
-   _llvm("llvm.cmpxchg", OperationKind::LLVM_CMPXCHG, mlir::LLVM::AtomicCmpXchgOp) \
-   _llvm("llvm.atomicrmw", OperationKind::LLVM_ATOMICRMW, mlir::LLVM::AtomicRMWOp) \
-   _llvm("llvm.bitcast", OperationKind::LLVM_BITCAST, mlir::LLVM::BitcastOp) \
-   _llvm("llvm.br", OperationKind::LLVM_BR, mlir::LLVM::BrOp) \
-   _llvm("llvm.call_intrinsic", OperationKind::LLVM_CALL_INTRINSIC, mlir::LLVM::CallIntrinsicOp) \
-   _llvm("llvm.call", OperationKind::LLVM_CALL, mlir::LLVM::CallOp) \
-   _llvm("llvm.comdat", OperationKind::LLVM_COMDAT, mlir::LLVM::ComdatOp) \
-   _llvm("llvm.comdat_selector", OperationKind::LLVM_COMDAT_SELECTOR, mlir::LLVM::ComdatSelectorOp) \
-   _llvm("llvm.cond_br", OperationKind::LLVM_COND_BR, mlir::LLVM::CondBrOp) \
-   _llvm("llvm.mlir.constant", OperationKind::LLVM_MLIR_CONSTANT, mlir::LLVM::ConstantOp) \
-   _llvm("llvm.extractelement", OperationKind::LLVM_EXTRACTELEMENT, mlir::LLVM::ExtractElementOp) \
-   _llvm("llvm.extractvalue", OperationKind::LLVM_EXTRACTVALUE, mlir::LLVM::ExtractValueOp) \
-   _llvm("llvm.fadd", OperationKind::LLVM_FADD, mlir::LLVM::FAddOp) \
-   _llvm("llvm.fcmp", OperationKind::LLVM_FCMP, mlir::LLVM::FCmpOp) \
-   _llvm("llvm.fdiv", OperationKind::LLVM_FDIV, mlir::LLVM::FDivOp) \
-   _llvm("llvm.fmul", OperationKind::LLVM_FMUL, mlir::LLVM::FMulOp) \
-   _llvm("llvm.fneg", OperationKind::LLVM_FNEG, mlir::LLVM::FNegOp) \
-   _llvm("llvm.fpext", OperationKind::LLVM_FPEXT, mlir::LLVM::FPExtOp) \
-   _llvm("llvm.fptosi", OperationKind::LLVM_FPTOSI, mlir::LLVM::FPToSIOp) \
-   _llvm("llvm.fptoui", OperationKind::LLVM_FPTOUI, mlir::LLVM::FPToUIOp) \
-   _llvm("llvm.fptrunc", OperationKind::LLVM_FPTRUNC, mlir::LLVM::FPTruncOp) \
-   _llvm("llvm.frem", OperationKind::LLVM_FREM, mlir::LLVM::FRemOp) \
-   _llvm("llvm.fsub", OperationKind::LLVM_FSUB, mlir::LLVM::FSubOp) \
-   _llvm("llvm.fence", OperationKind::LLVM_FENCE, mlir::LLVM::FenceOp) \
-   _llvm("llvm.freeze", OperationKind::LLVM_FREEZE, mlir::LLVM::FreezeOp) \
-   _llvm("llvm.getelementptr", OperationKind::LLVM_GETELEMENTPTR, mlir::LLVM::GEPOp) \
-   _llvm("llvm.mlir.global_ctors", OperationKind::LLVM_MLIR_GLOBAL_CTORS, mlir::LLVM::GlobalCtorsOp) \
-   _llvm("llvm.mlir.global_dtors", OperationKind::LLVM_MLIR_GLOBAL_DTORS, mlir::LLVM::GlobalDtorsOp) \
-   _llvm("llvm.mlir.global", OperationKind::LLVM_MLIR_GLOBAL, mlir::LLVM::GlobalOp) \
-   _llvm("llvm.icmp", OperationKind::LLVM_ICMP, mlir::LLVM::ICmpOp) \
-   _llvm("llvm.inline_asm", OperationKind::LLVM_INLINE_ASM, mlir::LLVM::InlineAsmOp) \
-   _llvm("llvm.insertelement", OperationKind::LLVM_INSERTELEMENT, mlir::LLVM::InsertElementOp) \
-   _llvm("llvm.insertvalue", OperationKind::LLVM_INSERTVALUE, mlir::LLVM::InsertValueOp) \
-   _llvm("llvm.inttoptr", OperationKind::LLVM_INTTOPTR, mlir::LLVM::IntToPtrOp) \
-   _llvm("llvm.invoke", OperationKind::LLVM_INVOKE, mlir::LLVM::InvokeOp) \
-   _llvm("llvm.func", OperationKind::LLVM_FUNC, mlir::LLVM::LLVMFuncOp) \
-   _llvm("llvm.lshr", OperationKind::LLVM_LSHR, mlir::LLVM::LShrOp) \
-   _llvm("llvm.landingpad", OperationKind::LLVM_LANDINGPAD, mlir::LLVM::LandingpadOp) \
-   _llvm("llvm.linker_options", OperationKind::LLVM_LINKER_OPTIONS, mlir::LLVM::LinkerOptionsOp) \
-   _llvm("llvm.load", OperationKind::LLVM_LOAD, mlir::LLVM::LoadOp) \
-   _llvm("llvm.mul", OperationKind::LLVM_MUL, mlir::LLVM::MulOp) \
-   _llvm("llvm.mlir.none", OperationKind::LLVM_MLIR_NONE, mlir::LLVM::NoneTokenOp) \
-   _llvm("llvm.or", OperationKind::LLVM_OR, mlir::LLVM::OrOp) \
-   _llvm("llvm.mlir.poison", OperationKind::LLVM_MLIR_POISON, mlir::LLVM::PoisonOp) \
-   _llvm("llvm.ptrtoint", OperationKind::LLVM_PTRTOINT, mlir::LLVM::PtrToIntOp) \
-   _llvm("llvm.resume", OperationKind::LLVM_RESUME, mlir::LLVM::ResumeOp) \
-   _llvm("llvm.return", OperationKind::LLVM_RETURN, mlir::LLVM::ReturnOp) \
-   _llvm("llvm.sdiv", OperationKind::LLVM_SDIV, mlir::LLVM::SDivOp) \
-   _llvm("llvm.sext", OperationKind::LLVM_SEXT, mlir::LLVM::SExtOp) \
-   _llvm("llvm.sitofp", OperationKind::LLVM_SITOFP, mlir::LLVM::SIToFPOp) \
-   _llvm("llvm.srem", OperationKind::LLVM_SREM, mlir::LLVM::SRemOp) \
-   _llvm("llvm.select", OperationKind::LLVM_SELECT, mlir::LLVM::SelectOp) \
-   _llvm("llvm.shl", OperationKind::LLVM_SHL, mlir::LLVM::ShlOp) \
-   _llvm("llvm.shufflevector", OperationKind::LLVM_SHUFFLEVECTOR, mlir::LLVM::ShuffleVectorOp) \
-   _llvm("llvm.store", OperationKind::LLVM_STORE, mlir::LLVM::StoreOp) \
-   _llvm("llvm.sub", OperationKind::LLVM_SUB, mlir::LLVM::SubOp) \
-   _llvm("llvm.switch", OperationKind::LLVM_SWITCH, mlir::LLVM::SwitchOp) \
-   _llvm("llvm.trunc", OperationKind::LLVM_TRUNC, mlir::LLVM::TruncOp) \
-   _llvm("llvm.udiv", OperationKind::LLVM_UDIV, mlir::LLVM::UDivOp) \
-   _llvm("llvm.uitofp", OperationKind::LLVM_UITOFP, mlir::LLVM::UIToFPOp) \
-   _llvm("llvm.urem", OperationKind::LLVM_UREM, mlir::LLVM::URemOp) \
-   _llvm("llvm.mlir.undef", OperationKind::LLVM_MLIR_UNDEF, mlir::LLVM::UndefOp) \
-   _llvm("llvm.unreachable", OperationKind::LLVM_UNREACHABLE, mlir::LLVM::UnreachableOp) \
-   _llvm("llvm.xor", OperationKind::LLVM_XOR, mlir::LLVM::XOrOp) \
-   _llvm("llvm.zext", OperationKind::LLVM_ZEXT, mlir::LLVM::ZExtOp) \
-   _llvm("llvm.mlir.zero", OperationKind::LLVM_MLIR_ZERO, mlir::LLVM::ZeroOp) \
-   _llvm("llvm.intr.abs", OperationKind::LLVM_INTR_ABS, mlir::LLVM::AbsOp) \
-   _llvm("llvm.intr.annotation", OperationKind::LLVM_INTR_ANNOTATION, mlir::LLVM::Annotation) \
-   _llvm("llvm.intr.assume", OperationKind::LLVM_INTR_ASSUME, mlir::LLVM::AssumeOp) \
-   _llvm("llvm.intr.bitreverse", OperationKind::LLVM_INTR_BITREVERSE, mlir::LLVM::BitReverseOp) \
-   _llvm("llvm.intr.bswap", OperationKind::LLVM_INTR_BSWAP, mlir::LLVM::ByteSwapOp) \
-   _llvm("llvm.intr.copysign", OperationKind::LLVM_INTR_COPYSIGN, mlir::LLVM::CopySignOp) \
-   _llvm("llvm.intr.coro.align", OperationKind::LLVM_INTR_CORO_ALIGN, mlir::LLVM::CoroAlignOp) \
-   _llvm("llvm.intr.coro.begin", OperationKind::LLVM_INTR_CORO_BEGIN, mlir::LLVM::CoroBeginOp) \
-   _llvm("llvm.intr.coro.end", OperationKind::LLVM_INTR_CORO_END, mlir::LLVM::CoroEndOp) \
-   _llvm("llvm.intr.coro.free", OperationKind::LLVM_INTR_CORO_FREE, mlir::LLVM::CoroFreeOp) \
-   _llvm("llvm.intr.coro.id", OperationKind::LLVM_INTR_CORO_ID, mlir::LLVM::CoroIdOp) \
-   _llvm("llvm.intr.coro.promise", OperationKind::LLVM_INTR_CORO_PROMISE, mlir::LLVM::CoroPromiseOp) \
-   _llvm("llvm.intr.coro.resume", OperationKind::LLVM_INTR_CORO_RESUME, mlir::LLVM::CoroResumeOp) \
-   _llvm("llvm.intr.coro.save", OperationKind::LLVM_INTR_CORO_SAVE, mlir::LLVM::CoroSaveOp) \
-   _llvm("llvm.intr.coro.size", OperationKind::LLVM_INTR_CORO_SIZE, mlir::LLVM::CoroSizeOp) \
-   _llvm("llvm.intr.coro.suspend", OperationKind::LLVM_INTR_CORO_SUSPEND, mlir::LLVM::CoroSuspendOp) \
-   _llvm("llvm.intr.cos", OperationKind::LLVM_INTR_COS, mlir::LLVM::CosOp) \
-   _llvm("llvm.intr.ctlz", OperationKind::LLVM_INTR_CTLZ, mlir::LLVM::CountLeadingZerosOp) \
-   _llvm("llvm.intr.cttz", OperationKind::LLVM_INTR_CTTZ, mlir::LLVM::CountTrailingZerosOp) \
-   _llvm("llvm.intr.ctpop", OperationKind::LLVM_INTR_CTPOP, mlir::LLVM::CtPopOp) \
-   _llvm("llvm.intr.dbg.declare", OperationKind::LLVM_INTR_DBG_DECLARE, mlir::LLVM::DbgDeclareOp) \
-   _llvm("llvm.intr.dbg.label", OperationKind::LLVM_INTR_DBG_LABEL, mlir::LLVM::DbgLabelOp) \
-   _llvm("llvm.intr.dbg.value", OperationKind::LLVM_INTR_DBG_VALUE, mlir::LLVM::DbgValueOp) \
-   _llvm("llvm.intr.debugtrap", OperationKind::LLVM_INTR_DEBUGTRAP, mlir::LLVM::DebugTrap) \
-   _llvm("llvm.intr.eh.typeid.for", OperationKind::LLVM_INTR_EH_TYPEID_FOR, mlir::LLVM::EhTypeidForOp) \
-   _llvm("llvm.intr.exp2", OperationKind::LLVM_INTR_EXP2, mlir::LLVM::Exp2Op) \
-   _llvm("llvm.intr.exp", OperationKind::LLVM_INTR_EXP, mlir::LLVM::ExpOp) \
-   _llvm("llvm.intr.expect", OperationKind::LLVM_INTR_EXPECT, mlir::LLVM::ExpectOp) \
-   _llvm("llvm.intr.expect.with.probability", OperationKind::LLVM_INTR_EXPECT_WITH_PROBABILITY, mlir::LLVM::ExpectWithProbabilityOp) \
-   _llvm("llvm.intr.fabs", OperationKind::LLVM_INTR_FABS, mlir::LLVM::FAbsOp) \
-   _llvm("llvm.intr.ceil", OperationKind::LLVM_INTR_CEIL, mlir::LLVM::FCeilOp) \
-   _llvm("llvm.intr.floor", OperationKind::LLVM_INTR_FLOOR, mlir::LLVM::FFloorOp) \
-   _llvm("llvm.intr.fma", OperationKind::LLVM_INTR_FMA, mlir::LLVM::FMAOp) \
-   _llvm("llvm.intr.fmuladd", OperationKind::LLVM_INTR_FMULADD, mlir::LLVM::FMulAddOp) \
-   _llvm("llvm.intr.trunc", OperationKind::LLVM_INTR_TRUNC, mlir::LLVM::FTruncOp) \
-   _llvm("llvm.intr.fshl", OperationKind::LLVM_INTR_FSHL, mlir::LLVM::FshlOp) \
-   _llvm("llvm.intr.fshr", OperationKind::LLVM_INTR_FSHR, mlir::LLVM::FshrOp) \
-   _llvm("llvm.intr.get.active.lane.mask", OperationKind::LLVM_INTR_GET_ACTIVE_LANE_MASK, mlir::LLVM::GetActiveLaneMaskOp) \
-   _llvm("llvm.intr.invariant.end", OperationKind::LLVM_INTR_INVARIANT_END, mlir::LLVM::InvariantEndOp) \
-   _llvm("llvm.intr.invariant.start", OperationKind::LLVM_INTR_INVARIANT_START, mlir::LLVM::InvariantStartOp) \
-   _llvm("llvm.intr.is.constant", OperationKind::LLVM_INTR_IS_CONSTANT, mlir::LLVM::IsConstantOp) \
-   _llvm("llvm.intr.is.fpclass", OperationKind::LLVM_INTR_IS_FPCLASS, mlir::LLVM::IsFPClass) \
-   _llvm("llvm.intr.lifetime.end", OperationKind::LLVM_INTR_LIFETIME_END, mlir::LLVM::LifetimeEndOp) \
-   _llvm("llvm.intr.lifetime.start", OperationKind::LLVM_INTR_LIFETIME_START, mlir::LLVM::LifetimeStartOp) \
-   _llvm("llvm.intr.llrint", OperationKind::LLVM_INTR_LLRINT, mlir::LLVM::LlrintOp) \
-   _llvm("llvm.intr.llround", OperationKind::LLVM_INTR_LLROUND, mlir::LLVM::LlroundOp) \
-   _llvm("llvm.intr.log10", OperationKind::LLVM_INTR_LOG10, mlir::LLVM::Log10Op) \
-   _llvm("llvm.intr.log2", OperationKind::LLVM_INTR_LOG2, mlir::LLVM::Log2Op) \
-   _llvm("llvm.intr.log", OperationKind::LLVM_INTR_LOG, mlir::LLVM::LogOp) \
-   _llvm("llvm.intr.lrint", OperationKind::LLVM_INTR_LRINT, mlir::LLVM::LrintOp) \
-   _llvm("llvm.intr.lround", OperationKind::LLVM_INTR_LROUND, mlir::LLVM::LroundOp) \
-   _llvm("llvm.intr.masked.load", OperationKind::LLVM_INTR_MASKED_LOAD, mlir::LLVM::MaskedLoadOp) \
-   _llvm("llvm.intr.masked.store", OperationKind::LLVM_INTR_MASKED_STORE, mlir::LLVM::MaskedStoreOp) \
-   _llvm("llvm.intr.matrix.column.major.load", OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_LOAD, mlir::LLVM::MatrixColumnMajorLoadOp) \
-   _llvm("llvm.intr.matrix.column.major.store", OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_STORE, mlir::LLVM::MatrixColumnMajorStoreOp) \
-   _llvm("llvm.intr.matrix.multiply", OperationKind::LLVM_INTR_MATRIX_MULTIPLY, mlir::LLVM::MatrixMultiplyOp) \
-   _llvm("llvm.intr.matrix.transpose", OperationKind::LLVM_INTR_MATRIX_TRANSPOSE, mlir::LLVM::MatrixTransposeOp) \
-   _llvm("llvm.intr.maxnum", OperationKind::LLVM_INTR_MAXNUM, mlir::LLVM::MaxNumOp) \
-   _llvm("llvm.intr.maximum", OperationKind::LLVM_INTR_MAXIMUM, mlir::LLVM::MaximumOp) \
-   _llvm("llvm.intr.memcpy.inline", OperationKind::LLVM_INTR_MEMCPY_INLINE, mlir::LLVM::MemcpyInlineOp) \
-   _llvm("llvm.intr.memcpy", OperationKind::LLVM_INTR_MEMCPY, mlir::LLVM::MemcpyOp) \
-   _llvm("llvm.intr.memmove", OperationKind::LLVM_INTR_MEMMOVE, mlir::LLVM::MemmoveOp) \
-   _llvm("llvm.intr.memset", OperationKind::LLVM_INTR_MEMSET, mlir::LLVM::MemsetOp) \
-   _llvm("llvm.intr.minnum", OperationKind::LLVM_INTR_MINNUM, mlir::LLVM::MinNumOp) \
-   _llvm("llvm.intr.minimum", OperationKind::LLVM_INTR_MINIMUM, mlir::LLVM::MinimumOp) \
-   _llvm("llvm.intr.nearbyint", OperationKind::LLVM_INTR_NEARBYINT, mlir::LLVM::NearbyintOp) \
-   _llvm("llvm.intr.experimental.noalias.scope.decl", OperationKind::LLVM_INTR_EXPERIMENTAL_NOALIAS_SCOPE_DECL, mlir::LLVM::NoAliasScopeDeclOp) \
-   _llvm("llvm.intr.powi", OperationKind::LLVM_INTR_POWI, mlir::LLVM::PowIOp) \
-   _llvm("llvm.intr.pow", OperationKind::LLVM_INTR_POW, mlir::LLVM::PowOp) \
-   _llvm("llvm.intr.prefetch", OperationKind::LLVM_INTR_PREFETCH, mlir::LLVM::Prefetch) \
-   _llvm("llvm.intr.ptr.annotation", OperationKind::LLVM_INTR_PTR_ANNOTATION, mlir::LLVM::PtrAnnotation) \
-   _llvm("llvm.intr.rint", OperationKind::LLVM_INTR_RINT, mlir::LLVM::RintOp) \
-   _llvm("llvm.intr.roundeven", OperationKind::LLVM_INTR_ROUNDEVEN, mlir::LLVM::RoundEvenOp) \
-   _llvm("llvm.intr.round", OperationKind::LLVM_INTR_ROUND, mlir::LLVM::RoundOp) \
-   _llvm("llvm.intr.sadd.sat", OperationKind::LLVM_INTR_SADD_SAT, mlir::LLVM::SAddSat) \
-   _llvm("llvm.intr.sadd.with.overflow", OperationKind::LLVM_INTR_SADD_WITH_OVERFLOW, mlir::LLVM::SAddWithOverflowOp) \
-   _llvm("llvm.intr.smax", OperationKind::LLVM_INTR_SMAX, mlir::LLVM::SMaxOp) \
-   _llvm("llvm.intr.smin", OperationKind::LLVM_INTR_SMIN, mlir::LLVM::SMinOp) \
-   _llvm("llvm.intr.smul.with.overflow", OperationKind::LLVM_INTR_SMUL_WITH_OVERFLOW, mlir::LLVM::SMulWithOverflowOp) \
-   _llvm("llvm.intr.ssa.copy", OperationKind::LLVM_INTR_SSA_COPY, mlir::LLVM::SSACopyOp) \
-   _llvm("llvm.intr.sshl.sat", OperationKind::LLVM_INTR_SSHL_SAT, mlir::LLVM::SSHLSat) \
-   _llvm("llvm.intr.ssub.sat", OperationKind::LLVM_INTR_SSUB_SAT, mlir::LLVM::SSubSat) \
-   _llvm("llvm.intr.ssub.with.overflow", OperationKind::LLVM_INTR_SSUB_WITH_OVERFLOW, mlir::LLVM::SSubWithOverflowOp) \
-   _llvm("llvm.intr.sin", OperationKind::LLVM_INTR_SIN, mlir::LLVM::SinOp) \
-   _llvm("llvm.intr.sqrt", OperationKind::LLVM_INTR_SQRT, mlir::LLVM::SqrtOp) \
-   _llvm("llvm.intr.stackrestore", OperationKind::LLVM_INTR_STACKRESTORE, mlir::LLVM::StackRestoreOp) \
-   _llvm("llvm.intr.stacksave", OperationKind::LLVM_INTR_STACKSAVE, mlir::LLVM::StackSaveOp) \
-   _llvm("llvm.intr.experimental.stepvector", OperationKind::LLVM_INTR_EXPERIMENTAL_STEPVECTOR, mlir::LLVM::StepVectorOp) \
-   _llvm("llvm.intr.threadlocal.address", OperationKind::LLVM_INTR_THREADLOCAL_ADDRESS, mlir::LLVM::ThreadlocalAddressOp) \
-   _llvm("llvm.intr.trap", OperationKind::LLVM_INTR_TRAP, mlir::LLVM::Trap) \
-   _llvm("llvm.intr.uadd.sat", OperationKind::LLVM_INTR_UADD_SAT, mlir::LLVM::UAddSat) \
-   _llvm("llvm.intr.uadd.with.overflow", OperationKind::LLVM_INTR_UADD_WITH_OVERFLOW, mlir::LLVM::UAddWithOverflowOp) \
-   _llvm("llvm.intr.ubsantrap", OperationKind::LLVM_INTR_UBSANTRAP, mlir::LLVM::UBSanTrap) \
-   _llvm("llvm.intr.umax", OperationKind::LLVM_INTR_UMAX, mlir::LLVM::UMaxOp) \
-   _llvm("llvm.intr.umin", OperationKind::LLVM_INTR_UMIN, mlir::LLVM::UMinOp) \
-   _llvm("llvm.intr.umul.with.overflow", OperationKind::LLVM_INTR_UMUL_WITH_OVERFLOW, mlir::LLVM::UMulWithOverflowOp) \
-   _llvm("llvm.intr.ushl.sat", OperationKind::LLVM_INTR_USHL_SAT, mlir::LLVM::USHLSat) \
-   _llvm("llvm.intr.usub.sat", OperationKind::LLVM_INTR_USUB_SAT, mlir::LLVM::USubSat) \
-   _llvm("llvm.intr.usub.with.overflow", OperationKind::LLVM_INTR_USUB_WITH_OVERFLOW, mlir::LLVM::USubWithOverflowOp) \
-   _llvm("llvm.intr.vp.ashr", OperationKind::LLVM_INTR_VP_ASHR, mlir::LLVM::VPAShrOp) \
-   _llvm("llvm.intr.vp.add", OperationKind::LLVM_INTR_VP_ADD, mlir::LLVM::VPAddOp) \
-   _llvm("llvm.intr.vp.and", OperationKind::LLVM_INTR_VP_AND, mlir::LLVM::VPAndOp) \
-   _llvm("llvm.intr.vp.fadd", OperationKind::LLVM_INTR_VP_FADD, mlir::LLVM::VPFAddOp) \
-   _llvm("llvm.intr.vp.fdiv", OperationKind::LLVM_INTR_VP_FDIV, mlir::LLVM::VPFDivOp) \
-   _llvm("llvm.intr.vp.fmuladd", OperationKind::LLVM_INTR_VP_FMULADD, mlir::LLVM::VPFMulAddOp) \
-   _llvm("llvm.intr.vp.fmul", OperationKind::LLVM_INTR_VP_FMUL, mlir::LLVM::VPFMulOp) \
-   _llvm("llvm.intr.vp.fneg", OperationKind::LLVM_INTR_VP_FNEG, mlir::LLVM::VPFNegOp) \
-   _llvm("llvm.intr.vp.fpext", OperationKind::LLVM_INTR_VP_FPEXT, mlir::LLVM::VPFPExtOp) \
-   _llvm("llvm.intr.vp.fptosi", OperationKind::LLVM_INTR_VP_FPTOSI, mlir::LLVM::VPFPToSIOp) \
-   _llvm("llvm.intr.vp.fptoui", OperationKind::LLVM_INTR_VP_FPTOUI, mlir::LLVM::VPFPToUIOp) \
-   _llvm("llvm.intr.vp.fptrunc", OperationKind::LLVM_INTR_VP_FPTRUNC, mlir::LLVM::VPFPTruncOp) \
-   _llvm("llvm.intr.vp.frem", OperationKind::LLVM_INTR_VP_FREM, mlir::LLVM::VPFRemOp) \
-   _llvm("llvm.intr.vp.fsub", OperationKind::LLVM_INTR_VP_FSUB, mlir::LLVM::VPFSubOp) \
-   _llvm("llvm.intr.vp.fma", OperationKind::LLVM_INTR_VP_FMA, mlir::LLVM::VPFmaOp) \
-   _llvm("llvm.intr.vp.inttoptr", OperationKind::LLVM_INTR_VP_INTTOPTR, mlir::LLVM::VPIntToPtrOp) \
-   _llvm("llvm.intr.vp.lshr", OperationKind::LLVM_INTR_VP_LSHR, mlir::LLVM::VPLShrOp) \
-   _llvm("llvm.intr.vp.load", OperationKind::LLVM_INTR_VP_LOAD, mlir::LLVM::VPLoadOp) \
-   _llvm("llvm.intr.vp.merge", OperationKind::LLVM_INTR_VP_MERGE, mlir::LLVM::VPMergeMinOp) \
-   _llvm("llvm.intr.vp.mul", OperationKind::LLVM_INTR_VP_MUL, mlir::LLVM::VPMulOp) \
-   _llvm("llvm.intr.vp.or", OperationKind::LLVM_INTR_VP_OR, mlir::LLVM::VPOrOp) \
-   _llvm("llvm.intr.vp.ptrtoint", OperationKind::LLVM_INTR_VP_PTRTOINT, mlir::LLVM::VPPtrToIntOp) \
-   _llvm("llvm.intr.vp.reduce.add", OperationKind::LLVM_INTR_VP_REDUCE_ADD, mlir::LLVM::VPReduceAddOp) \
-   _llvm("llvm.intr.vp.reduce.and", OperationKind::LLVM_INTR_VP_REDUCE_AND, mlir::LLVM::VPReduceAndOp) \
-   _llvm("llvm.intr.vp.reduce.fadd", OperationKind::LLVM_INTR_VP_REDUCE_FADD, mlir::LLVM::VPReduceFAddOp) \
-   _llvm("llvm.intr.vp.reduce.fmax", OperationKind::LLVM_INTR_VP_REDUCE_FMAX, mlir::LLVM::VPReduceFMaxOp) \
-   _llvm("llvm.intr.vp.reduce.fmin", OperationKind::LLVM_INTR_VP_REDUCE_FMIN, mlir::LLVM::VPReduceFMinOp) \
-   _llvm("llvm.intr.vp.reduce.fmul", OperationKind::LLVM_INTR_VP_REDUCE_FMUL, mlir::LLVM::VPReduceFMulOp) \
-   _llvm("llvm.intr.vp.reduce.mul", OperationKind::LLVM_INTR_VP_REDUCE_MUL, mlir::LLVM::VPReduceMulOp) \
-   _llvm("llvm.intr.vp.reduce.or", OperationKind::LLVM_INTR_VP_REDUCE_OR, mlir::LLVM::VPReduceOrOp) \
-   _llvm("llvm.intr.vp.reduce.smax", OperationKind::LLVM_INTR_VP_REDUCE_SMAX, mlir::LLVM::VPReduceSMaxOp) \
-   _llvm("llvm.intr.vp.reduce.smin", OperationKind::LLVM_INTR_VP_REDUCE_SMIN, mlir::LLVM::VPReduceSMinOp) \
-   _llvm("llvm.intr.vp.reduce.umax", OperationKind::LLVM_INTR_VP_REDUCE_UMAX, mlir::LLVM::VPReduceUMaxOp) \
-   _llvm("llvm.intr.vp.reduce.umin", OperationKind::LLVM_INTR_VP_REDUCE_UMIN, mlir::LLVM::VPReduceUMinOp) \
-   _llvm("llvm.intr.vp.reduce.xor", OperationKind::LLVM_INTR_VP_REDUCE_XOR, mlir::LLVM::VPReduceXorOp) \
-   _llvm("llvm.intr.vp.sdiv", OperationKind::LLVM_INTR_VP_SDIV, mlir::LLVM::VPSDivOp) \
-   _llvm("llvm.intr.vp.sext", OperationKind::LLVM_INTR_VP_SEXT, mlir::LLVM::VPSExtOp) \
-   _llvm("llvm.intr.vp.sitofp", OperationKind::LLVM_INTR_VP_SITOFP, mlir::LLVM::VPSIToFPOp) \
-   _llvm("llvm.intr.vp.srem", OperationKind::LLVM_INTR_VP_SREM, mlir::LLVM::VPSRemOp) \
-   _llvm("llvm.intr.vp.select", OperationKind::LLVM_INTR_VP_SELECT, mlir::LLVM::VPSelectMinOp) \
-   _llvm("llvm.intr.vp.shl", OperationKind::LLVM_INTR_VP_SHL, mlir::LLVM::VPShlOp) \
-   _llvm("llvm.intr.vp.store", OperationKind::LLVM_INTR_VP_STORE, mlir::LLVM::VPStoreOp) \
-   _llvm("llvm.intr.experimental.vp.strided.load", OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_LOAD, mlir::LLVM::VPStridedLoadOp) \
-   _llvm("llvm.intr.experimental.vp.strided.store", OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_STORE, mlir::LLVM::VPStridedStoreOp) \
-   _llvm("llvm.intr.vp.sub", OperationKind::LLVM_INTR_VP_SUB, mlir::LLVM::VPSubOp) \
-   _llvm("llvm.intr.vp.trunc", OperationKind::LLVM_INTR_VP_TRUNC, mlir::LLVM::VPTruncOp) \
-   _llvm("llvm.intr.vp.udiv", OperationKind::LLVM_INTR_VP_UDIV, mlir::LLVM::VPUDivOp) \
-   _llvm("llvm.intr.vp.uitofp", OperationKind::LLVM_INTR_VP_UITOFP, mlir::LLVM::VPUIToFPOp) \
-   _llvm("llvm.intr.vp.urem", OperationKind::LLVM_INTR_VP_UREM, mlir::LLVM::VPURemOp) \
-   _llvm("llvm.intr.vp.xor", OperationKind::LLVM_INTR_VP_XOR, mlir::LLVM::VPXorOp) \
-   _llvm("llvm.intr.vp.zext", OperationKind::LLVM_INTR_VP_ZEXT, mlir::LLVM::VPZExtOp) \
-   _llvm("llvm.intr.vacopy", OperationKind::LLVM_INTR_VACOPY, mlir::LLVM::VaCopyOp) \
-   _llvm("llvm.intr.vaend", OperationKind::LLVM_INTR_VAEND, mlir::LLVM::VaEndOp) \
-   _llvm("llvm.intr.vastart", OperationKind::LLVM_INTR_VASTART, mlir::LLVM::VaStartOp) \
-   _llvm("llvm.intr.var.annotation", OperationKind::LLVM_INTR_VAR_ANNOTATION, mlir::LLVM::VarAnnotation) \
-   _llvm("llvm.intr.masked.compressstore", OperationKind::LLVM_INTR_MASKED_COMPRESSSTORE, mlir::LLVM::masked_compressstore) \
-   _llvm("llvm.intr.masked.expandload", OperationKind::LLVM_INTR_MASKED_EXPANDLOAD, mlir::LLVM::masked_expandload) \
-   _llvm("llvm.intr.masked.gather", OperationKind::LLVM_INTR_MASKED_GATHER, mlir::LLVM::masked_gather) \
-   _llvm("llvm.intr.masked.scatter", OperationKind::LLVM_INTR_MASKED_SCATTER, mlir::LLVM::masked_scatter) \
-   _llvm("llvm.intr.vector.extract", OperationKind::LLVM_INTR_VECTOR_EXTRACT, mlir::LLVM::vector_extract) \
-   _llvm("llvm.intr.vector.insert", OperationKind::LLVM_INTR_VECTOR_INSERT, mlir::LLVM::vector_insert) \
-   _llvm("llvm.intr.vector.reduce.add", OperationKind::LLVM_INTR_VECTOR_REDUCE_ADD, mlir::LLVM::vector_reduce_add) \
-   _llvm("llvm.intr.vector.reduce.and", OperationKind::LLVM_INTR_VECTOR_REDUCE_AND, mlir::LLVM::vector_reduce_and) \
-   _llvm("llvm.intr.vector.reduce.fadd", OperationKind::LLVM_INTR_VECTOR_REDUCE_FADD, mlir::LLVM::vector_reduce_fadd) \
-   _llvm("llvm.intr.vector.reduce.fmax", OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAX, mlir::LLVM::vector_reduce_fmax) \
-   _llvm("llvm.intr.vector.reduce.fmaximum", OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAXIMUM, mlir::LLVM::vector_reduce_fmaximum) \
-   _llvm("llvm.intr.vector.reduce.fmin", OperationKind::LLVM_INTR_VECTOR_REDUCE_FMIN, mlir::LLVM::vector_reduce_fmin) \
-   _llvm("llvm.intr.vector.reduce.fminimum", OperationKind::LLVM_INTR_VECTOR_REDUCE_FMINIMUM, mlir::LLVM::vector_reduce_fminimum) \
-   _llvm("llvm.intr.vector.reduce.fmul", OperationKind::LLVM_INTR_VECTOR_REDUCE_FMUL, mlir::LLVM::vector_reduce_fmul) \
-   _llvm("llvm.intr.vector.reduce.mul", OperationKind::LLVM_INTR_VECTOR_REDUCE_MUL, mlir::LLVM::vector_reduce_mul) \
-   _llvm("llvm.intr.vector.reduce.or", OperationKind::LLVM_INTR_VECTOR_REDUCE_OR, mlir::LLVM::vector_reduce_or) \
-   _llvm("llvm.intr.vector.reduce.smax", OperationKind::LLVM_INTR_VECTOR_REDUCE_SMAX, mlir::LLVM::vector_reduce_smax) \
-   _llvm("llvm.intr.vector.reduce.smin", OperationKind::LLVM_INTR_VECTOR_REDUCE_SMIN, mlir::LLVM::vector_reduce_smin) \
-   _llvm("llvm.intr.vector.reduce.umax", OperationKind::LLVM_INTR_VECTOR_REDUCE_UMAX, mlir::LLVM::vector_reduce_umax) \
-   _llvm("llvm.intr.vector.reduce.umin", OperationKind::LLVM_INTR_VECTOR_REDUCE_UMIN, mlir::LLVM::vector_reduce_umin) \
-   _llvm("llvm.intr.vector.reduce.xor", OperationKind::LLVM_INTR_VECTOR_REDUCE_XOR, mlir::LLVM::vector_reduce_xor) \
-   _llvm("llvm.intr.vscale", OperationKind::LLVM_INTR_VSCALE, mlir::LLVM::vscale) \
-   _memref("memref.assume_alignment", OperationKind::MEMREF_ASSUME_ALIGNMENT, mlir::memref::AssumeAlignmentOp) \
-   _memref("memref.atomic_rmw", OperationKind::MEMREF_ATOMIC_RMW, mlir::memref::AtomicRMWOp) \
-   _memref("memref.atomic_yield", OperationKind::MEMREF_ATOMIC_YIELD, mlir::memref::AtomicYieldOp) \
-   _memref("memref.copy", OperationKind::MEMREF_COPY, mlir::memref::CopyOp) \
-   _memref("memref.generic_atomic_rmw", OperationKind::MEMREF_GENERIC_ATOMIC_RMW, mlir::memref::GenericAtomicRMWOp) \
-   _memref("memref.load", OperationKind::MEMREF_LOAD, mlir::memref::LoadOp) \
-   _memref("memref.alloc", OperationKind::MEMREF_ALLOC, mlir::memref::AllocOp) \
-   _memref("memref.alloca", OperationKind::MEMREF_ALLOCA, mlir::memref::AllocaOp) \
-   _memref("memref.alloca_scope", OperationKind::MEMREF_ALLOCA_SCOPE, mlir::memref::AllocaScopeOp) \
-   _memref("memref.alloca_scope.return", OperationKind::MEMREF_ALLOCA_SCOPE_RETURN, mlir::memref::AllocaScopeReturnOp) \
-   _memref("memref.cast", OperationKind::MEMREF_CAST, mlir::memref::CastOp) \
-   _memref("memref.collapse_shape", OperationKind::MEMREF_COLLAPSE_SHAPE, mlir::memref::CollapseShapeOp) \
-   _memref("memref.dealloc", OperationKind::MEMREF_DEALLOC, mlir::memref::DeallocOp) \
-   _memref("memref.dim", OperationKind::MEMREF_DIM, mlir::memref::DimOp) \
-   _memref("memref.dma_start", OperationKind::MEMREF_DMA_START, mlir::memref::DmaStartOp) \
-   _memref("memref.dma_wait", OperationKind::MEMREF_DMA_WAIT, mlir::memref::DmaWaitOp) \
-   _memref("memref.expand_shape", OperationKind::MEMREF_EXPAND_SHAPE, mlir::memref::ExpandShapeOp) \
-   _memref("memref.extract_aligned_pointer_as_index", OperationKind::MEMREF_EXTRACT_ALIGNED_POINTER_AS_INDEX, mlir::memref::ExtractAlignedPointerAsIndexOp) \
-   _memref("memref.extract_strided_metadata", OperationKind::MEMREF_EXTRACT_STRIDED_METADATA, mlir::memref::ExtractStridedMetadataOp) \
-   _memref("memref.get_global", OperationKind::MEMREF_GET_GLOBAL, mlir::memref::GetGlobalOp) \
-   _memref("memref.global", OperationKind::MEMREF_GLOBAL, mlir::memref::GlobalOp) \
-   _memref("memref.memory_space_cast", OperationKind::MEMREF_MEMORY_SPACE_CAST, mlir::memref::MemorySpaceCastOp) \
-   _memref("memref.prefetch", OperationKind::MEMREF_PREFETCH, mlir::memref::PrefetchOp) \
-   _memref("memref.rank", OperationKind::MEMREF_RANK, mlir::memref::RankOp) \
-   _memref("memref.realloc", OperationKind::MEMREF_REALLOC, mlir::memref::ReallocOp) \
-   _memref("memref.reinterpret_cast", OperationKind::MEMREF_REINTERPRET_CAST, mlir::memref::ReinterpretCastOp) \
-   _memref("memref.reshape", OperationKind::MEMREF_RESHAPE, mlir::memref::ReshapeOp) \
-   _memref("memref.store", OperationKind::MEMREF_STORE, mlir::memref::StoreOp) \
-   _memref("memref.transpose", OperationKind::MEMREF_TRANSPOSE, mlir::memref::TransposeOp) \
-   _memref("memref.view", OperationKind::MEMREF_VIEW, mlir::memref::ViewOp) \
-   _memref("memref.subview", OperationKind::MEMREF_SUBVIEW, mlir::memref::SubViewOp) \
-   _abi("abi.call_args", OperationKind::ABI_CALL_ARGS, vast::abi::CallArgsOp) \
-   _abi("abi.call_exec", OperationKind::ABI_CALL_EXEC, vast::abi::CallExecutionOp) \
-   _abi("abi.call", OperationKind::ABI_CALL, vast::abi::CallOp) \
-   _abi("abi.call_rets", OperationKind::ABI_CALL_RETS, vast::abi::CallRetsOp) \
-   _abi("abi.direct", OperationKind::ABI_DIRECT, vast::abi::DirectOp) \
-   _abi("abi.epilogue", OperationKind::ABI_EPILOGUE, vast::abi::EpilogueOp) \
-   _abi("abi.func", OperationKind::ABI_FUNC, vast::abi::FuncOp) \
-   _abi("abi.indirect", OperationKind::ABI_INDIRECT, vast::abi::IndirectOp) \
-   _abi("abi.prologue", OperationKind::ABI_PROLOGUE, vast::abi::PrologueOp) \
-   _abi("abi.ret_direct", OperationKind::ABI_RET_DIRECT, vast::abi::RetDirectOp) \
-   _abi("abi.yield", OperationKind::ABI_YIELD, vast::abi::YieldOp) \
-   _ll("ll.alloca", OperationKind::LL_ALLOCA, vast::ll::Alloca) \
-   _ll("ll.arg_alloca", OperationKind::LL_ARG_ALLOCA, vast::ll::ArgAlloca) \
-   _ll("ll.br", OperationKind::LL_BR, vast::ll::Br) \
-   _ll("ll.concat", OperationKind::LL_CONCAT, vast::ll::Concat) \
-   _ll("ll.cond_br", OperationKind::LL_COND_BR, vast::ll::CondBr) \
-   _ll("ll.cond_scope_ret", OperationKind::LL_COND_SCOPE_RET, vast::ll::CondScopeRet) \
-   _ll("ll.extract", OperationKind::LL_EXTRACT, vast::ll::Extract) \
-   _ll("ll.initialize", OperationKind::LL_INITIALIZE, vast::ll::InitializeVar) \
-   _ll("ll.inline_scope", OperationKind::LL_INLINE_SCOPE, vast::ll::InlineScope) \
-   _ll("ll.load", OperationKind::LL_LOAD, vast::ll::Load) \
-   _ll("ll.func", OperationKind::LL_FUNC, vast::ll::FuncOp) \
-   _ll("ll.gep", OperationKind::LL_GEP, vast::ll::StructGEPOp) \
-   _ll("ll.return", OperationKind::LL_RETURN, vast::ll::ReturnOp) \
-   _ll("ll.scope", OperationKind::LL_SCOPE, vast::ll::Scope) \
-   _ll("ll.scope_recurse", OperationKind::LL_SCOPE_RECURSE, vast::ll::ScopeRecurse) \
-   _ll("ll.scope_ret", OperationKind::LL_SCOPE_RET, vast::ll::ScopeRet) \
-   _ll("ll.store", OperationKind::LL_STORE, vast::ll::Store) \
-   _ll("ll.subscript", OperationKind::LL_SUBSCRIPT, vast::ll::Subscript) \
-   _ll("ll.uninitialized_var", OperationKind::LL_UNINITIALIZED_VAR, vast::ll::UninitializedVar) \
-   _hl("hl.access", OperationKind::HL_ACCESS, vast::hl::AccessSpecifierOp) \
-   _hl("hl.assign.fadd", OperationKind::HL_ASSIGN_FADD, vast::hl::AddFAssignOp) \
-   _hl("hl.fadd", OperationKind::HL_FADD, vast::hl::AddFOp) \
-   _hl("hl.assign.add", OperationKind::HL_ASSIGN_ADD, vast::hl::AddIAssignOp) \
-   _hl("hl.add", OperationKind::HL_ADD, vast::hl::AddIOp) \
-   _hl("hl.labeladdr", OperationKind::HL_LABELADDR, vast::hl::AddrLabelExpr) \
-   _hl("hl.addressof", OperationKind::HL_ADDRESSOF, vast::hl::AddressOf) \
-   _hl("hl.alignof.expr", OperationKind::HL_ALIGNOF_EXPR, vast::hl::AlignOfExprOp) \
-   _hl("hl.alignof.type", OperationKind::HL_ALIGNOF_TYPE, vast::hl::AlignOfTypeOp) \
-   _hl("hl.asm", OperationKind::HL_ASM, vast::hl::AsmOp) \
-   _hl("hl.assign", OperationKind::HL_ASSIGN, vast::hl::AssignOp) \
-   _hl("hl.attributed_stmt", OperationKind::HL_ATTRIBUTED_STMT, vast::hl::AttributedStmt) \
-   _hl("hl.assign.bin.ashr", OperationKind::HL_ASSIGN_BIN_ASHR, vast::hl::BinAShrAssignOp) \
-   _hl("hl.bin.ashr", OperationKind::HL_BIN_ASHR, vast::hl::BinAShrOp) \
-   _hl("hl.assign.bin.and", OperationKind::HL_ASSIGN_BIN_AND, vast::hl::BinAndAssignOp) \
-   _hl("hl.bin.and", OperationKind::HL_BIN_AND, vast::hl::BinAndOp) \
-   _hl("hl.bin.comma", OperationKind::HL_BIN_COMMA, vast::hl::BinComma) \
-   _hl("hl.bin.land", OperationKind::HL_BIN_LAND, vast::hl::BinLAndOp) \
-   _hl("hl.bin.lor", OperationKind::HL_BIN_LOR, vast::hl::BinLOrOp) \
-   _hl("hl.assign.bin.lshr", OperationKind::HL_ASSIGN_BIN_LSHR, vast::hl::BinLShrAssignOp) \
-   _hl("hl.bin.lshr", OperationKind::HL_BIN_LSHR, vast::hl::BinLShrOp) \
-   _hl("hl.assign.bin.or", OperationKind::HL_ASSIGN_BIN_OR, vast::hl::BinOrAssignOp) \
-   _hl("hl.bin.or", OperationKind::HL_BIN_OR, vast::hl::BinOrOp) \
-   _hl("hl.assign.bin.shl", OperationKind::HL_ASSIGN_BIN_SHL, vast::hl::BinShlAssignOp) \
-   _hl("hl.bin.shl", OperationKind::HL_BIN_SHL, vast::hl::BinShlOp) \
-   _hl("hl.assign.bin.xor", OperationKind::HL_ASSIGN_BIN_XOR, vast::hl::BinXorAssignOp) \
-   _hl("hl.bin.xor", OperationKind::HL_BIN_XOR, vast::hl::BinXorOp) \
-   _hl("hl.binary_cond", OperationKind::HL_BINARY_COND, vast::hl::BinaryCondOp) \
-   _hl("hl.break", OperationKind::HL_BREAK, vast::hl::BreakOp) \
-   _hl("hl.builtin_bitcast", OperationKind::HL_BUILTIN_BITCAST, vast::hl::BuiltinBitCastOp) \
-   _hl("hl.builtin_types_compatible_p.type", OperationKind::HL_BUILTIN_TYPES_COMPATIBLE_P_TYPE, vast::hl::BuiltinTypesCompatiblePOp) \
-   _hl("hl.cstyle_cast", OperationKind::HL_CSTYLE_CAST, vast::hl::CStyleCastOp) \
-   _hl("hl.call", OperationKind::HL_CALL, vast::hl::CallOp) \
-   _hl("hl.case", OperationKind::HL_CASE, vast::hl::CaseOp) \
-   _hl("hl.choose_expr", OperationKind::HL_CHOOSE_EXPR, vast::hl::ChooseExprOp) \
-   _hl("hl.class", OperationKind::HL_CLASS, vast::hl::ClassDeclOp) \
-   _hl("hl.cmp", OperationKind::HL_CMP, vast::hl::CmpOp) \
-   _hl("hl.compound_literal", OperationKind::HL_COMPOUND_LITERAL, vast::hl::CompoundLiteralOp) \
-   _hl("hl.cond", OperationKind::HL_COND, vast::hl::CondOp) \
-   _hl("hl.cond.yield", OperationKind::HL_COND_YIELD, vast::hl::CondYieldOp) \
-   _hl("hl.const", OperationKind::HL_CONST, vast::hl::ConstantOp) \
-   _hl("hl.continue", OperationKind::HL_CONTINUE, vast::hl::ContinueOp) \
-   _hl("hl.base", OperationKind::HL_BASE, vast::hl::CxxBaseSpecifierOp) \
-   _hl("hl.cxxstruct", OperationKind::HL_CXXSTRUCT, vast::hl::CxxStructDeclOp) \
-   _hl("hl.ref", OperationKind::HL_REF, vast::hl::DeclRefOp) \
-   _hl("hl.default", OperationKind::HL_DEFAULT, vast::hl::DefaultOp) \
-   _hl("hl.deref", OperationKind::HL_DEREF, vast::hl::Deref) \
-   _hl("hl.assign.fdiv", OperationKind::HL_ASSIGN_FDIV, vast::hl::DivFAssignOp) \
-   _hl("hl.fdiv", OperationKind::HL_FDIV, vast::hl::DivFOp) \
-   _hl("hl.assign.sdiv", OperationKind::HL_ASSIGN_SDIV, vast::hl::DivSAssignOp) \
-   _hl("hl.sdiv", OperationKind::HL_SDIV, vast::hl::DivSOp) \
-   _hl("hl.assign.udiv", OperationKind::HL_ASSIGN_UDIV, vast::hl::DivUAssignOp) \
-   _hl("hl.udiv", OperationKind::HL_UDIV, vast::hl::DivUOp) \
-   _hl("hl.do", OperationKind::HL_DO, vast::hl::DoOp) \
-   _hl("hl.empty.decl", OperationKind::HL_EMPTY_DECL, vast::hl::EmptyDeclOp) \
-   _hl("hl.enum.const", OperationKind::HL_ENUM_CONST, vast::hl::EnumConstantOp) \
-   _hl("hl.enum", OperationKind::HL_ENUM, vast::hl::EnumDeclOp) \
-   _hl("hl.enumref", OperationKind::HL_ENUMREF, vast::hl::EnumRefOp) \
-   _hl("hl.expr", OperationKind::HL_EXPR, vast::hl::ExprOp) \
-   _hl("hl.gnu.extension", OperationKind::HL_GNU_EXTENSION, vast::hl::ExtensionOp) \
-   _hl("hl.fcmp", OperationKind::HL_FCMP, vast::hl::FCmpOp) \
-   _hl("hl.field", OperationKind::HL_FIELD, vast::hl::FieldDeclOp) \
-   _hl("hl.file_scope_asm", OperationKind::HL_FILE_SCOPE_ASM, vast::hl::FileScopeAsmOp) \
-   _hl("hl.for", OperationKind::HL_FOR, vast::hl::ForOp) \
-   _hl("hl.func", OperationKind::HL_FUNC, vast::hl::FuncOp) \
-   _hl("hl.funcref", OperationKind::HL_FUNCREF, vast::hl::FuncRefOp) \
-   _hl("hl.generic_asoc", OperationKind::HL_GENERIC_ASOC, vast::hl::GenericAssocExpr) \
-   _hl("hl.generic_expr", OperationKind::HL_GENERIC_EXPR, vast::hl::GenericSelectionExpr) \
-   _hl("hl.globref", OperationKind::HL_GLOBREF, vast::hl::GlobalRefOp) \
-   _hl("hl.goto", OperationKind::HL_GOTO, vast::hl::GotoStmt) \
-   _hl("hl.if", OperationKind::HL_IF, vast::hl::IfOp) \
-   _hl("hl.imag", OperationKind::HL_IMAG, vast::hl::ImagOp) \
-   _hl("hl.implicit_cast", OperationKind::HL_IMPLICIT_CAST, vast::hl::ImplicitCastOp) \
-   _hl("hl.indirect_call", OperationKind::HL_INDIRECT_CALL, vast::hl::IndirectCallOp) \
-   _hl("hl.indirect_goto", OperationKind::HL_INDIRECT_GOTO, vast::hl::IndirectGotoStmt) \
-   _hl("hl.initlist", OperationKind::HL_INITLIST, vast::hl::InitListExpr) \
-   _hl("hl.const.init", OperationKind::HL_CONST_INIT, vast::hl::InitializedConstantOp) \
-   _hl("hl.lnot", OperationKind::HL_LNOT, vast::hl::LNotOp) \
-   _hl("hl.label.decl", OperationKind::HL_LABEL_DECL, vast::hl::LabelDeclOp) \
-   _hl("hl.label", OperationKind::HL_LABEL, vast::hl::LabelStmt) \
-   _hl("hl.minus", OperationKind::HL_MINUS, vast::hl::MinusOp) \
-   _hl("hl.assign.fmul", OperationKind::HL_ASSIGN_FMUL, vast::hl::MulFAssignOp) \
-   _hl("hl.fmul", OperationKind::HL_FMUL, vast::hl::MulFOp) \
-   _hl("hl.assign.mul", OperationKind::HL_ASSIGN_MUL, vast::hl::MulIAssignOp) \
-   _hl("hl.mul", OperationKind::HL_MUL, vast::hl::MulIOp) \
-   _hl("hl.not", OperationKind::HL_NOT, vast::hl::NotOp) \
-   _hl("hl.null", OperationKind::HL_NULL, vast::hl::NullStmt) \
-   _hl("hl.offsetof.expr", OperationKind::HL_OFFSETOF_EXPR, vast::hl::OffsetOfExprOp) \
-   _hl("hl.opaque_expr", OperationKind::HL_OPAQUE_EXPR, vast::hl::OpaqueValueExpr) \
-   _hl("hl.plus", OperationKind::HL_PLUS, vast::hl::PlusOp) \
-   _hl("hl.post.dec", OperationKind::HL_POST_DEC, vast::hl::PostDecOp) \
-   _hl("hl.post.inc", OperationKind::HL_POST_INC, vast::hl::PostIncOp) \
-   _hl("hl.pre.dec", OperationKind::HL_PRE_DEC, vast::hl::PreDecOp) \
-   _hl("hl.pre.inc", OperationKind::HL_PRE_INC, vast::hl::PreIncOp) \
-   _hl("hl.predefined.expr", OperationKind::HL_PREDEFINED_EXPR, vast::hl::PredefinedExpr) \
-   _hl("hl.preferred_alignof.expr", OperationKind::HL_PREFERRED_ALIGNOF_EXPR, vast::hl::PreferredAlignOfExprOp) \
-   _hl("hl.preferred_alignof.type", OperationKind::HL_PREFERRED_ALIGNOF_TYPE, vast::hl::PreferredAlignOfTypeOp) \
-   _hl("hl.real", OperationKind::HL_REAL, vast::hl::RealOp) \
-   _hl("hl.member", OperationKind::HL_MEMBER, vast::hl::RecordMemberOp) \
-   _hl("hl.assign.frem", OperationKind::HL_ASSIGN_FREM, vast::hl::RemFAssignOp) \
-   _hl("hl.frem", OperationKind::HL_FREM, vast::hl::RemFOp) \
-   _hl("hl.assign.srem", OperationKind::HL_ASSIGN_SREM, vast::hl::RemSAssignOp) \
-   _hl("hl.srem", OperationKind::HL_SREM, vast::hl::RemSOp) \
-   _hl("hl.assign.urem", OperationKind::HL_ASSIGN_UREM, vast::hl::RemUAssignOp) \
-   _hl("hl.urem", OperationKind::HL_UREM, vast::hl::RemUOp) \
-   _hl("hl.return", OperationKind::HL_RETURN, vast::hl::ReturnOp) \
-   _hl("hl.sizeof.expr", OperationKind::HL_SIZEOF_EXPR, vast::hl::SizeOfExprOp) \
-   _hl("hl.sizeof.type", OperationKind::HL_SIZEOF_TYPE, vast::hl::SizeOfTypeOp) \
-   _hl("hl.static_assert", OperationKind::HL_STATIC_ASSERT, vast::hl::StaticAssertDecl) \
-   _hl("hl.stmt.expr", OperationKind::HL_STMT_EXPR, vast::hl::StmtExprOp) \
-   _hl("hl.struct", OperationKind::HL_STRUCT, vast::hl::StructDeclOp) \
-   _hl("hl.assign.fsub", OperationKind::HL_ASSIGN_FSUB, vast::hl::SubFAssignOp) \
-   _hl("hl.fsub", OperationKind::HL_FSUB, vast::hl::SubFOp) \
-   _hl("hl.assign.sub", OperationKind::HL_ASSIGN_SUB, vast::hl::SubIAssignOp) \
-   _hl("hl.sub", OperationKind::HL_SUB, vast::hl::SubIOp) \
-   _hl("hl.subscript", OperationKind::HL_SUBSCRIPT, vast::hl::SubscriptOp) \
-   _hl("hl.switch", OperationKind::HL_SWITCH, vast::hl::SwitchOp) \
-   _hl("hl.this", OperationKind::HL_THIS, vast::hl::ThisOp) \
-   _hl("hl.translation_unit", OperationKind::HL_TRANSLATION_UNIT, vast::hl::TranslationUnitOp) \
-   _hl("hl.alias", OperationKind::HL_ALIAS, vast::hl::TypeAliasOp) \
-   _hl("hl.type", OperationKind::HL_TYPE, vast::hl::TypeDeclOp) \
-   _hl("hl.typedef", OperationKind::HL_TYPEDEF, vast::hl::TypeDefOp) \
-   _hl("hl.typeof.expr", OperationKind::HL_TYPEOF_EXPR, vast::hl::TypeOfExprOp) \
-   _hl("hl.type.yield", OperationKind::HL_TYPE_YIELD, vast::hl::TypeYieldOp) \
-   _hl("hl.union", OperationKind::HL_UNION, vast::hl::UnionDeclOp) \
-   _hl("hl.unreachable", OperationKind::HL_UNREACHABLE, vast::hl::UnreachableOp) \
-   _hl("hl.va_arg_expr", OperationKind::HL_VA_ARG_EXPR, vast::hl::VAArgExpr) \
-   _hl("hl.value.yield", OperationKind::HL_VALUE_YIELD, vast::hl::ValueYieldOp) \
-   _hl("hl.var", OperationKind::HL_VAR, vast::hl::VarDeclOp) \
-   _hl("hl.while", OperationKind::HL_WHILE, vast::hl::WhileOp) \
-   _core("core.bin.land", OperationKind::CORE_BIN_LAND, vast::core::BinLAndOp) \
-   _core("core.bin.lor", OperationKind::CORE_BIN_LOR, vast::core::BinLOrOp) \
-   _core("core.implicit.return", OperationKind::CORE_IMPLICIT_RETURN, vast::core::ImplicitReturnOp) \
-   _core("core.lazy.op", OperationKind::CORE_LAZY_OP, vast::core::LazyOp) \
-   _core("core.module", OperationKind::CORE_MODULE, vast::core::ModuleOp) \
-   _core("core.scope", OperationKind::CORE_SCOPE, vast::core::ScopeOp) \
-   _core("core.select", OperationKind::CORE_SELECT, vast::core::SelectOp) \
-   _unsup("unsup.decl", OperationKind::UNSUP_DECL, vast::unsup::UnsupportedDecl) \
-   _unsup("unsup.stmt", OperationKind::UNSUP_STMT, vast::unsup::UnsupportedStmt)
-
-#define MX_IR_NUM_MLIR_OPS 450
-
diff --git a/lib/IR/OperationKind.cpp b/lib/IR/OperationKind.cpp
deleted file mode 100644
index 0b936730f..000000000
--- a/lib/IR/OperationKind.cpp
+++ /dev/null
@@ -1,989 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/OperationKind.h>
-
-namespace mx {
-
-const char *EnumeratorName(ir::OperationKind kind) {
-  switch (kind) {
-    default: return "UNKNOWN";
-    case ir::OperationKind::BUILTIN_MODULE: return "BUILTIN_MODULE";
-    case ir::OperationKind::BUILTIN_UNREALIZED_CONVERSION_CAST: return "BUILTIN_UNREALIZED_CONVERSION_CAST";
-    case ir::OperationKind::LLVM_ASHR: return "LLVM_ASHR";
-    case ir::OperationKind::LLVM_ADD: return "LLVM_ADD";
-    case ir::OperationKind::LLVM_ADDRSPACECAST: return "LLVM_ADDRSPACECAST";
-    case ir::OperationKind::LLVM_MLIR_ADDRESSOF: return "LLVM_MLIR_ADDRESSOF";
-    case ir::OperationKind::LLVM_ALLOCA: return "LLVM_ALLOCA";
-    case ir::OperationKind::LLVM_AND: return "LLVM_AND";
-    case ir::OperationKind::LLVM_CMPXCHG: return "LLVM_CMPXCHG";
-    case ir::OperationKind::LLVM_ATOMICRMW: return "LLVM_ATOMICRMW";
-    case ir::OperationKind::LLVM_BITCAST: return "LLVM_BITCAST";
-    case ir::OperationKind::LLVM_BR: return "LLVM_BR";
-    case ir::OperationKind::LLVM_CALL_INTRINSIC: return "LLVM_CALL_INTRINSIC";
-    case ir::OperationKind::LLVM_CALL: return "LLVM_CALL";
-    case ir::OperationKind::LLVM_COMDAT: return "LLVM_COMDAT";
-    case ir::OperationKind::LLVM_COMDAT_SELECTOR: return "LLVM_COMDAT_SELECTOR";
-    case ir::OperationKind::LLVM_COND_BR: return "LLVM_COND_BR";
-    case ir::OperationKind::LLVM_MLIR_CONSTANT: return "LLVM_MLIR_CONSTANT";
-    case ir::OperationKind::LLVM_EXTRACTELEMENT: return "LLVM_EXTRACTELEMENT";
-    case ir::OperationKind::LLVM_EXTRACTVALUE: return "LLVM_EXTRACTVALUE";
-    case ir::OperationKind::LLVM_FADD: return "LLVM_FADD";
-    case ir::OperationKind::LLVM_FCMP: return "LLVM_FCMP";
-    case ir::OperationKind::LLVM_FDIV: return "LLVM_FDIV";
-    case ir::OperationKind::LLVM_FMUL: return "LLVM_FMUL";
-    case ir::OperationKind::LLVM_FNEG: return "LLVM_FNEG";
-    case ir::OperationKind::LLVM_FPEXT: return "LLVM_FPEXT";
-    case ir::OperationKind::LLVM_FPTOSI: return "LLVM_FPTOSI";
-    case ir::OperationKind::LLVM_FPTOUI: return "LLVM_FPTOUI";
-    case ir::OperationKind::LLVM_FPTRUNC: return "LLVM_FPTRUNC";
-    case ir::OperationKind::LLVM_FREM: return "LLVM_FREM";
-    case ir::OperationKind::LLVM_FSUB: return "LLVM_FSUB";
-    case ir::OperationKind::LLVM_FENCE: return "LLVM_FENCE";
-    case ir::OperationKind::LLVM_FREEZE: return "LLVM_FREEZE";
-    case ir::OperationKind::LLVM_GETELEMENTPTR: return "LLVM_GETELEMENTPTR";
-    case ir::OperationKind::LLVM_MLIR_GLOBAL_CTORS: return "LLVM_MLIR_GLOBAL_CTORS";
-    case ir::OperationKind::LLVM_MLIR_GLOBAL_DTORS: return "LLVM_MLIR_GLOBAL_DTORS";
-    case ir::OperationKind::LLVM_MLIR_GLOBAL: return "LLVM_MLIR_GLOBAL";
-    case ir::OperationKind::LLVM_ICMP: return "LLVM_ICMP";
-    case ir::OperationKind::LLVM_INLINE_ASM: return "LLVM_INLINE_ASM";
-    case ir::OperationKind::LLVM_INSERTELEMENT: return "LLVM_INSERTELEMENT";
-    case ir::OperationKind::LLVM_INSERTVALUE: return "LLVM_INSERTVALUE";
-    case ir::OperationKind::LLVM_INTTOPTR: return "LLVM_INTTOPTR";
-    case ir::OperationKind::LLVM_INVOKE: return "LLVM_INVOKE";
-    case ir::OperationKind::LLVM_FUNC: return "LLVM_FUNC";
-    case ir::OperationKind::LLVM_LSHR: return "LLVM_LSHR";
-    case ir::OperationKind::LLVM_LANDINGPAD: return "LLVM_LANDINGPAD";
-    case ir::OperationKind::LLVM_LINKER_OPTIONS: return "LLVM_LINKER_OPTIONS";
-    case ir::OperationKind::LLVM_LOAD: return "LLVM_LOAD";
-    case ir::OperationKind::LLVM_MUL: return "LLVM_MUL";
-    case ir::OperationKind::LLVM_MLIR_NONE: return "LLVM_MLIR_NONE";
-    case ir::OperationKind::LLVM_OR: return "LLVM_OR";
-    case ir::OperationKind::LLVM_MLIR_POISON: return "LLVM_MLIR_POISON";
-    case ir::OperationKind::LLVM_PTRTOINT: return "LLVM_PTRTOINT";
-    case ir::OperationKind::LLVM_RESUME: return "LLVM_RESUME";
-    case ir::OperationKind::LLVM_RETURN: return "LLVM_RETURN";
-    case ir::OperationKind::LLVM_SDIV: return "LLVM_SDIV";
-    case ir::OperationKind::LLVM_SEXT: return "LLVM_SEXT";
-    case ir::OperationKind::LLVM_SITOFP: return "LLVM_SITOFP";
-    case ir::OperationKind::LLVM_SREM: return "LLVM_SREM";
-    case ir::OperationKind::LLVM_SELECT: return "LLVM_SELECT";
-    case ir::OperationKind::LLVM_SHL: return "LLVM_SHL";
-    case ir::OperationKind::LLVM_SHUFFLEVECTOR: return "LLVM_SHUFFLEVECTOR";
-    case ir::OperationKind::LLVM_STORE: return "LLVM_STORE";
-    case ir::OperationKind::LLVM_SUB: return "LLVM_SUB";
-    case ir::OperationKind::LLVM_SWITCH: return "LLVM_SWITCH";
-    case ir::OperationKind::LLVM_TRUNC: return "LLVM_TRUNC";
-    case ir::OperationKind::LLVM_UDIV: return "LLVM_UDIV";
-    case ir::OperationKind::LLVM_UITOFP: return "LLVM_UITOFP";
-    case ir::OperationKind::LLVM_UREM: return "LLVM_UREM";
-    case ir::OperationKind::LLVM_MLIR_UNDEF: return "LLVM_MLIR_UNDEF";
-    case ir::OperationKind::LLVM_UNREACHABLE: return "LLVM_UNREACHABLE";
-    case ir::OperationKind::LLVM_XOR: return "LLVM_XOR";
-    case ir::OperationKind::LLVM_ZEXT: return "LLVM_ZEXT";
-    case ir::OperationKind::LLVM_MLIR_ZERO: return "LLVM_MLIR_ZERO";
-    case ir::OperationKind::LLVM_INTR_ABS: return "LLVM_INTR_ABS";
-    case ir::OperationKind::LLVM_INTR_ANNOTATION: return "LLVM_INTR_ANNOTATION";
-    case ir::OperationKind::LLVM_INTR_ASSUME: return "LLVM_INTR_ASSUME";
-    case ir::OperationKind::LLVM_INTR_BITREVERSE: return "LLVM_INTR_BITREVERSE";
-    case ir::OperationKind::LLVM_INTR_BSWAP: return "LLVM_INTR_BSWAP";
-    case ir::OperationKind::LLVM_INTR_COPYSIGN: return "LLVM_INTR_COPYSIGN";
-    case ir::OperationKind::LLVM_INTR_CORO_ALIGN: return "LLVM_INTR_CORO_ALIGN";
-    case ir::OperationKind::LLVM_INTR_CORO_BEGIN: return "LLVM_INTR_CORO_BEGIN";
-    case ir::OperationKind::LLVM_INTR_CORO_END: return "LLVM_INTR_CORO_END";
-    case ir::OperationKind::LLVM_INTR_CORO_FREE: return "LLVM_INTR_CORO_FREE";
-    case ir::OperationKind::LLVM_INTR_CORO_ID: return "LLVM_INTR_CORO_ID";
-    case ir::OperationKind::LLVM_INTR_CORO_PROMISE: return "LLVM_INTR_CORO_PROMISE";
-    case ir::OperationKind::LLVM_INTR_CORO_RESUME: return "LLVM_INTR_CORO_RESUME";
-    case ir::OperationKind::LLVM_INTR_CORO_SAVE: return "LLVM_INTR_CORO_SAVE";
-    case ir::OperationKind::LLVM_INTR_CORO_SIZE: return "LLVM_INTR_CORO_SIZE";
-    case ir::OperationKind::LLVM_INTR_CORO_SUSPEND: return "LLVM_INTR_CORO_SUSPEND";
-    case ir::OperationKind::LLVM_INTR_COS: return "LLVM_INTR_COS";
-    case ir::OperationKind::LLVM_INTR_CTLZ: return "LLVM_INTR_CTLZ";
-    case ir::OperationKind::LLVM_INTR_CTTZ: return "LLVM_INTR_CTTZ";
-    case ir::OperationKind::LLVM_INTR_CTPOP: return "LLVM_INTR_CTPOP";
-    case ir::OperationKind::LLVM_INTR_DBG_DECLARE: return "LLVM_INTR_DBG_DECLARE";
-    case ir::OperationKind::LLVM_INTR_DBG_LABEL: return "LLVM_INTR_DBG_LABEL";
-    case ir::OperationKind::LLVM_INTR_DBG_VALUE: return "LLVM_INTR_DBG_VALUE";
-    case ir::OperationKind::LLVM_INTR_DEBUGTRAP: return "LLVM_INTR_DEBUGTRAP";
-    case ir::OperationKind::LLVM_INTR_EH_TYPEID_FOR: return "LLVM_INTR_EH_TYPEID_FOR";
-    case ir::OperationKind::LLVM_INTR_EXP2: return "LLVM_INTR_EXP2";
-    case ir::OperationKind::LLVM_INTR_EXP: return "LLVM_INTR_EXP";
-    case ir::OperationKind::LLVM_INTR_EXPECT: return "LLVM_INTR_EXPECT";
-    case ir::OperationKind::LLVM_INTR_EXPECT_WITH_PROBABILITY: return "LLVM_INTR_EXPECT_WITH_PROBABILITY";
-    case ir::OperationKind::LLVM_INTR_FABS: return "LLVM_INTR_FABS";
-    case ir::OperationKind::LLVM_INTR_CEIL: return "LLVM_INTR_CEIL";
-    case ir::OperationKind::LLVM_INTR_FLOOR: return "LLVM_INTR_FLOOR";
-    case ir::OperationKind::LLVM_INTR_FMA: return "LLVM_INTR_FMA";
-    case ir::OperationKind::LLVM_INTR_FMULADD: return "LLVM_INTR_FMULADD";
-    case ir::OperationKind::LLVM_INTR_TRUNC: return "LLVM_INTR_TRUNC";
-    case ir::OperationKind::LLVM_INTR_FSHL: return "LLVM_INTR_FSHL";
-    case ir::OperationKind::LLVM_INTR_FSHR: return "LLVM_INTR_FSHR";
-    case ir::OperationKind::LLVM_INTR_GET_ACTIVE_LANE_MASK: return "LLVM_INTR_GET_ACTIVE_LANE_MASK";
-    case ir::OperationKind::LLVM_INTR_INVARIANT_END: return "LLVM_INTR_INVARIANT_END";
-    case ir::OperationKind::LLVM_INTR_INVARIANT_START: return "LLVM_INTR_INVARIANT_START";
-    case ir::OperationKind::LLVM_INTR_IS_CONSTANT: return "LLVM_INTR_IS_CONSTANT";
-    case ir::OperationKind::LLVM_INTR_IS_FPCLASS: return "LLVM_INTR_IS_FPCLASS";
-    case ir::OperationKind::LLVM_INTR_LIFETIME_END: return "LLVM_INTR_LIFETIME_END";
-    case ir::OperationKind::LLVM_INTR_LIFETIME_START: return "LLVM_INTR_LIFETIME_START";
-    case ir::OperationKind::LLVM_INTR_LLRINT: return "LLVM_INTR_LLRINT";
-    case ir::OperationKind::LLVM_INTR_LLROUND: return "LLVM_INTR_LLROUND";
-    case ir::OperationKind::LLVM_INTR_LOG10: return "LLVM_INTR_LOG10";
-    case ir::OperationKind::LLVM_INTR_LOG2: return "LLVM_INTR_LOG2";
-    case ir::OperationKind::LLVM_INTR_LOG: return "LLVM_INTR_LOG";
-    case ir::OperationKind::LLVM_INTR_LRINT: return "LLVM_INTR_LRINT";
-    case ir::OperationKind::LLVM_INTR_LROUND: return "LLVM_INTR_LROUND";
-    case ir::OperationKind::LLVM_INTR_MASKED_LOAD: return "LLVM_INTR_MASKED_LOAD";
-    case ir::OperationKind::LLVM_INTR_MASKED_STORE: return "LLVM_INTR_MASKED_STORE";
-    case ir::OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_LOAD: return "LLVM_INTR_MATRIX_COLUMN_MAJOR_LOAD";
-    case ir::OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_STORE: return "LLVM_INTR_MATRIX_COLUMN_MAJOR_STORE";
-    case ir::OperationKind::LLVM_INTR_MATRIX_MULTIPLY: return "LLVM_INTR_MATRIX_MULTIPLY";
-    case ir::OperationKind::LLVM_INTR_MATRIX_TRANSPOSE: return "LLVM_INTR_MATRIX_TRANSPOSE";
-    case ir::OperationKind::LLVM_INTR_MAXNUM: return "LLVM_INTR_MAXNUM";
-    case ir::OperationKind::LLVM_INTR_MAXIMUM: return "LLVM_INTR_MAXIMUM";
-    case ir::OperationKind::LLVM_INTR_MEMCPY_INLINE: return "LLVM_INTR_MEMCPY_INLINE";
-    case ir::OperationKind::LLVM_INTR_MEMCPY: return "LLVM_INTR_MEMCPY";
-    case ir::OperationKind::LLVM_INTR_MEMMOVE: return "LLVM_INTR_MEMMOVE";
-    case ir::OperationKind::LLVM_INTR_MEMSET: return "LLVM_INTR_MEMSET";
-    case ir::OperationKind::LLVM_INTR_MINNUM: return "LLVM_INTR_MINNUM";
-    case ir::OperationKind::LLVM_INTR_MINIMUM: return "LLVM_INTR_MINIMUM";
-    case ir::OperationKind::LLVM_INTR_NEARBYINT: return "LLVM_INTR_NEARBYINT";
-    case ir::OperationKind::LLVM_INTR_EXPERIMENTAL_NOALIAS_SCOPE_DECL: return "LLVM_INTR_EXPERIMENTAL_NOALIAS_SCOPE_DECL";
-    case ir::OperationKind::LLVM_INTR_POWI: return "LLVM_INTR_POWI";
-    case ir::OperationKind::LLVM_INTR_POW: return "LLVM_INTR_POW";
-    case ir::OperationKind::LLVM_INTR_PREFETCH: return "LLVM_INTR_PREFETCH";
-    case ir::OperationKind::LLVM_INTR_PTR_ANNOTATION: return "LLVM_INTR_PTR_ANNOTATION";
-    case ir::OperationKind::LLVM_INTR_RINT: return "LLVM_INTR_RINT";
-    case ir::OperationKind::LLVM_INTR_ROUNDEVEN: return "LLVM_INTR_ROUNDEVEN";
-    case ir::OperationKind::LLVM_INTR_ROUND: return "LLVM_INTR_ROUND";
-    case ir::OperationKind::LLVM_INTR_SADD_SAT: return "LLVM_INTR_SADD_SAT";
-    case ir::OperationKind::LLVM_INTR_SADD_WITH_OVERFLOW: return "LLVM_INTR_SADD_WITH_OVERFLOW";
-    case ir::OperationKind::LLVM_INTR_SMAX: return "LLVM_INTR_SMAX";
-    case ir::OperationKind::LLVM_INTR_SMIN: return "LLVM_INTR_SMIN";
-    case ir::OperationKind::LLVM_INTR_SMUL_WITH_OVERFLOW: return "LLVM_INTR_SMUL_WITH_OVERFLOW";
-    case ir::OperationKind::LLVM_INTR_SSA_COPY: return "LLVM_INTR_SSA_COPY";
-    case ir::OperationKind::LLVM_INTR_SSHL_SAT: return "LLVM_INTR_SSHL_SAT";
-    case ir::OperationKind::LLVM_INTR_SSUB_SAT: return "LLVM_INTR_SSUB_SAT";
-    case ir::OperationKind::LLVM_INTR_SSUB_WITH_OVERFLOW: return "LLVM_INTR_SSUB_WITH_OVERFLOW";
-    case ir::OperationKind::LLVM_INTR_SIN: return "LLVM_INTR_SIN";
-    case ir::OperationKind::LLVM_INTR_SQRT: return "LLVM_INTR_SQRT";
-    case ir::OperationKind::LLVM_INTR_STACKRESTORE: return "LLVM_INTR_STACKRESTORE";
-    case ir::OperationKind::LLVM_INTR_STACKSAVE: return "LLVM_INTR_STACKSAVE";
-    case ir::OperationKind::LLVM_INTR_EXPERIMENTAL_STEPVECTOR: return "LLVM_INTR_EXPERIMENTAL_STEPVECTOR";
-    case ir::OperationKind::LLVM_INTR_THREADLOCAL_ADDRESS: return "LLVM_INTR_THREADLOCAL_ADDRESS";
-    case ir::OperationKind::LLVM_INTR_TRAP: return "LLVM_INTR_TRAP";
-    case ir::OperationKind::LLVM_INTR_UADD_SAT: return "LLVM_INTR_UADD_SAT";
-    case ir::OperationKind::LLVM_INTR_UADD_WITH_OVERFLOW: return "LLVM_INTR_UADD_WITH_OVERFLOW";
-    case ir::OperationKind::LLVM_INTR_UBSANTRAP: return "LLVM_INTR_UBSANTRAP";
-    case ir::OperationKind::LLVM_INTR_UMAX: return "LLVM_INTR_UMAX";
-    case ir::OperationKind::LLVM_INTR_UMIN: return "LLVM_INTR_UMIN";
-    case ir::OperationKind::LLVM_INTR_UMUL_WITH_OVERFLOW: return "LLVM_INTR_UMUL_WITH_OVERFLOW";
-    case ir::OperationKind::LLVM_INTR_USHL_SAT: return "LLVM_INTR_USHL_SAT";
-    case ir::OperationKind::LLVM_INTR_USUB_SAT: return "LLVM_INTR_USUB_SAT";
-    case ir::OperationKind::LLVM_INTR_USUB_WITH_OVERFLOW: return "LLVM_INTR_USUB_WITH_OVERFLOW";
-    case ir::OperationKind::LLVM_INTR_VP_ASHR: return "LLVM_INTR_VP_ASHR";
-    case ir::OperationKind::LLVM_INTR_VP_ADD: return "LLVM_INTR_VP_ADD";
-    case ir::OperationKind::LLVM_INTR_VP_AND: return "LLVM_INTR_VP_AND";
-    case ir::OperationKind::LLVM_INTR_VP_FADD: return "LLVM_INTR_VP_FADD";
-    case ir::OperationKind::LLVM_INTR_VP_FDIV: return "LLVM_INTR_VP_FDIV";
-    case ir::OperationKind::LLVM_INTR_VP_FMULADD: return "LLVM_INTR_VP_FMULADD";
-    case ir::OperationKind::LLVM_INTR_VP_FMUL: return "LLVM_INTR_VP_FMUL";
-    case ir::OperationKind::LLVM_INTR_VP_FNEG: return "LLVM_INTR_VP_FNEG";
-    case ir::OperationKind::LLVM_INTR_VP_FPEXT: return "LLVM_INTR_VP_FPEXT";
-    case ir::OperationKind::LLVM_INTR_VP_FPTOSI: return "LLVM_INTR_VP_FPTOSI";
-    case ir::OperationKind::LLVM_INTR_VP_FPTOUI: return "LLVM_INTR_VP_FPTOUI";
-    case ir::OperationKind::LLVM_INTR_VP_FPTRUNC: return "LLVM_INTR_VP_FPTRUNC";
-    case ir::OperationKind::LLVM_INTR_VP_FREM: return "LLVM_INTR_VP_FREM";
-    case ir::OperationKind::LLVM_INTR_VP_FSUB: return "LLVM_INTR_VP_FSUB";
-    case ir::OperationKind::LLVM_INTR_VP_FMA: return "LLVM_INTR_VP_FMA";
-    case ir::OperationKind::LLVM_INTR_VP_INTTOPTR: return "LLVM_INTR_VP_INTTOPTR";
-    case ir::OperationKind::LLVM_INTR_VP_LSHR: return "LLVM_INTR_VP_LSHR";
-    case ir::OperationKind::LLVM_INTR_VP_LOAD: return "LLVM_INTR_VP_LOAD";
-    case ir::OperationKind::LLVM_INTR_VP_MERGE: return "LLVM_INTR_VP_MERGE";
-    case ir::OperationKind::LLVM_INTR_VP_MUL: return "LLVM_INTR_VP_MUL";
-    case ir::OperationKind::LLVM_INTR_VP_OR: return "LLVM_INTR_VP_OR";
-    case ir::OperationKind::LLVM_INTR_VP_PTRTOINT: return "LLVM_INTR_VP_PTRTOINT";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_ADD: return "LLVM_INTR_VP_REDUCE_ADD";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_AND: return "LLVM_INTR_VP_REDUCE_AND";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_FADD: return "LLVM_INTR_VP_REDUCE_FADD";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_FMAX: return "LLVM_INTR_VP_REDUCE_FMAX";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_FMIN: return "LLVM_INTR_VP_REDUCE_FMIN";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_FMUL: return "LLVM_INTR_VP_REDUCE_FMUL";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_MUL: return "LLVM_INTR_VP_REDUCE_MUL";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_OR: return "LLVM_INTR_VP_REDUCE_OR";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_SMAX: return "LLVM_INTR_VP_REDUCE_SMAX";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_SMIN: return "LLVM_INTR_VP_REDUCE_SMIN";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_UMAX: return "LLVM_INTR_VP_REDUCE_UMAX";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_UMIN: return "LLVM_INTR_VP_REDUCE_UMIN";
-    case ir::OperationKind::LLVM_INTR_VP_REDUCE_XOR: return "LLVM_INTR_VP_REDUCE_XOR";
-    case ir::OperationKind::LLVM_INTR_VP_SDIV: return "LLVM_INTR_VP_SDIV";
-    case ir::OperationKind::LLVM_INTR_VP_SEXT: return "LLVM_INTR_VP_SEXT";
-    case ir::OperationKind::LLVM_INTR_VP_SITOFP: return "LLVM_INTR_VP_SITOFP";
-    case ir::OperationKind::LLVM_INTR_VP_SREM: return "LLVM_INTR_VP_SREM";
-    case ir::OperationKind::LLVM_INTR_VP_SELECT: return "LLVM_INTR_VP_SELECT";
-    case ir::OperationKind::LLVM_INTR_VP_SHL: return "LLVM_INTR_VP_SHL";
-    case ir::OperationKind::LLVM_INTR_VP_STORE: return "LLVM_INTR_VP_STORE";
-    case ir::OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_LOAD: return "LLVM_INTR_EXPERIMENTAL_VP_STRIDED_LOAD";
-    case ir::OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_STORE: return "LLVM_INTR_EXPERIMENTAL_VP_STRIDED_STORE";
-    case ir::OperationKind::LLVM_INTR_VP_SUB: return "LLVM_INTR_VP_SUB";
-    case ir::OperationKind::LLVM_INTR_VP_TRUNC: return "LLVM_INTR_VP_TRUNC";
-    case ir::OperationKind::LLVM_INTR_VP_UDIV: return "LLVM_INTR_VP_UDIV";
-    case ir::OperationKind::LLVM_INTR_VP_UITOFP: return "LLVM_INTR_VP_UITOFP";
-    case ir::OperationKind::LLVM_INTR_VP_UREM: return "LLVM_INTR_VP_UREM";
-    case ir::OperationKind::LLVM_INTR_VP_XOR: return "LLVM_INTR_VP_XOR";
-    case ir::OperationKind::LLVM_INTR_VP_ZEXT: return "LLVM_INTR_VP_ZEXT";
-    case ir::OperationKind::LLVM_INTR_VACOPY: return "LLVM_INTR_VACOPY";
-    case ir::OperationKind::LLVM_INTR_VAEND: return "LLVM_INTR_VAEND";
-    case ir::OperationKind::LLVM_INTR_VASTART: return "LLVM_INTR_VASTART";
-    case ir::OperationKind::LLVM_INTR_VAR_ANNOTATION: return "LLVM_INTR_VAR_ANNOTATION";
-    case ir::OperationKind::LLVM_INTR_MASKED_COMPRESSSTORE: return "LLVM_INTR_MASKED_COMPRESSSTORE";
-    case ir::OperationKind::LLVM_INTR_MASKED_EXPANDLOAD: return "LLVM_INTR_MASKED_EXPANDLOAD";
-    case ir::OperationKind::LLVM_INTR_MASKED_GATHER: return "LLVM_INTR_MASKED_GATHER";
-    case ir::OperationKind::LLVM_INTR_MASKED_SCATTER: return "LLVM_INTR_MASKED_SCATTER";
-    case ir::OperationKind::LLVM_INTR_VECTOR_EXTRACT: return "LLVM_INTR_VECTOR_EXTRACT";
-    case ir::OperationKind::LLVM_INTR_VECTOR_INSERT: return "LLVM_INTR_VECTOR_INSERT";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_ADD: return "LLVM_INTR_VECTOR_REDUCE_ADD";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_AND: return "LLVM_INTR_VECTOR_REDUCE_AND";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FADD: return "LLVM_INTR_VECTOR_REDUCE_FADD";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAX: return "LLVM_INTR_VECTOR_REDUCE_FMAX";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAXIMUM: return "LLVM_INTR_VECTOR_REDUCE_FMAXIMUM";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMIN: return "LLVM_INTR_VECTOR_REDUCE_FMIN";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMINIMUM: return "LLVM_INTR_VECTOR_REDUCE_FMINIMUM";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMUL: return "LLVM_INTR_VECTOR_REDUCE_FMUL";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_MUL: return "LLVM_INTR_VECTOR_REDUCE_MUL";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_OR: return "LLVM_INTR_VECTOR_REDUCE_OR";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_SMAX: return "LLVM_INTR_VECTOR_REDUCE_SMAX";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_SMIN: return "LLVM_INTR_VECTOR_REDUCE_SMIN";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_UMAX: return "LLVM_INTR_VECTOR_REDUCE_UMAX";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_UMIN: return "LLVM_INTR_VECTOR_REDUCE_UMIN";
-    case ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_XOR: return "LLVM_INTR_VECTOR_REDUCE_XOR";
-    case ir::OperationKind::LLVM_INTR_VSCALE: return "LLVM_INTR_VSCALE";
-    case ir::OperationKind::MEMREF_ASSUME_ALIGNMENT: return "MEMREF_ASSUME_ALIGNMENT";
-    case ir::OperationKind::MEMREF_ATOMIC_RMW: return "MEMREF_ATOMIC_RMW";
-    case ir::OperationKind::MEMREF_ATOMIC_YIELD: return "MEMREF_ATOMIC_YIELD";
-    case ir::OperationKind::MEMREF_COPY: return "MEMREF_COPY";
-    case ir::OperationKind::MEMREF_GENERIC_ATOMIC_RMW: return "MEMREF_GENERIC_ATOMIC_RMW";
-    case ir::OperationKind::MEMREF_LOAD: return "MEMREF_LOAD";
-    case ir::OperationKind::MEMREF_ALLOC: return "MEMREF_ALLOC";
-    case ir::OperationKind::MEMREF_ALLOCA: return "MEMREF_ALLOCA";
-    case ir::OperationKind::MEMREF_ALLOCA_SCOPE: return "MEMREF_ALLOCA_SCOPE";
-    case ir::OperationKind::MEMREF_ALLOCA_SCOPE_RETURN: return "MEMREF_ALLOCA_SCOPE_RETURN";
-    case ir::OperationKind::MEMREF_CAST: return "MEMREF_CAST";
-    case ir::OperationKind::MEMREF_COLLAPSE_SHAPE: return "MEMREF_COLLAPSE_SHAPE";
-    case ir::OperationKind::MEMREF_DEALLOC: return "MEMREF_DEALLOC";
-    case ir::OperationKind::MEMREF_DIM: return "MEMREF_DIM";
-    case ir::OperationKind::MEMREF_DMA_START: return "MEMREF_DMA_START";
-    case ir::OperationKind::MEMREF_DMA_WAIT: return "MEMREF_DMA_WAIT";
-    case ir::OperationKind::MEMREF_EXPAND_SHAPE: return "MEMREF_EXPAND_SHAPE";
-    case ir::OperationKind::MEMREF_EXTRACT_ALIGNED_POINTER_AS_INDEX: return "MEMREF_EXTRACT_ALIGNED_POINTER_AS_INDEX";
-    case ir::OperationKind::MEMREF_EXTRACT_STRIDED_METADATA: return "MEMREF_EXTRACT_STRIDED_METADATA";
-    case ir::OperationKind::MEMREF_GET_GLOBAL: return "MEMREF_GET_GLOBAL";
-    case ir::OperationKind::MEMREF_GLOBAL: return "MEMREF_GLOBAL";
-    case ir::OperationKind::MEMREF_MEMORY_SPACE_CAST: return "MEMREF_MEMORY_SPACE_CAST";
-    case ir::OperationKind::MEMREF_PREFETCH: return "MEMREF_PREFETCH";
-    case ir::OperationKind::MEMREF_RANK: return "MEMREF_RANK";
-    case ir::OperationKind::MEMREF_REALLOC: return "MEMREF_REALLOC";
-    case ir::OperationKind::MEMREF_REINTERPRET_CAST: return "MEMREF_REINTERPRET_CAST";
-    case ir::OperationKind::MEMREF_RESHAPE: return "MEMREF_RESHAPE";
-    case ir::OperationKind::MEMREF_STORE: return "MEMREF_STORE";
-    case ir::OperationKind::MEMREF_TRANSPOSE: return "MEMREF_TRANSPOSE";
-    case ir::OperationKind::MEMREF_VIEW: return "MEMREF_VIEW";
-    case ir::OperationKind::MEMREF_SUBVIEW: return "MEMREF_SUBVIEW";
-    case ir::OperationKind::ABI_CALL_ARGS: return "ABI_CALL_ARGS";
-    case ir::OperationKind::ABI_CALL_EXEC: return "ABI_CALL_EXEC";
-    case ir::OperationKind::ABI_CALL: return "ABI_CALL";
-    case ir::OperationKind::ABI_CALL_RETS: return "ABI_CALL_RETS";
-    case ir::OperationKind::ABI_DIRECT: return "ABI_DIRECT";
-    case ir::OperationKind::ABI_EPILOGUE: return "ABI_EPILOGUE";
-    case ir::OperationKind::ABI_FUNC: return "ABI_FUNC";
-    case ir::OperationKind::ABI_INDIRECT: return "ABI_INDIRECT";
-    case ir::OperationKind::ABI_PROLOGUE: return "ABI_PROLOGUE";
-    case ir::OperationKind::ABI_RET_DIRECT: return "ABI_RET_DIRECT";
-    case ir::OperationKind::ABI_YIELD: return "ABI_YIELD";
-    case ir::OperationKind::LL_ALLOCA: return "LL_ALLOCA";
-    case ir::OperationKind::LL_ARG_ALLOCA: return "LL_ARG_ALLOCA";
-    case ir::OperationKind::LL_BR: return "LL_BR";
-    case ir::OperationKind::LL_CONCAT: return "LL_CONCAT";
-    case ir::OperationKind::LL_COND_BR: return "LL_COND_BR";
-    case ir::OperationKind::LL_COND_SCOPE_RET: return "LL_COND_SCOPE_RET";
-    case ir::OperationKind::LL_EXTRACT: return "LL_EXTRACT";
-    case ir::OperationKind::LL_INITIALIZE: return "LL_INITIALIZE";
-    case ir::OperationKind::LL_INLINE_SCOPE: return "LL_INLINE_SCOPE";
-    case ir::OperationKind::LL_LOAD: return "LL_LOAD";
-    case ir::OperationKind::LL_FUNC: return "LL_FUNC";
-    case ir::OperationKind::LL_GEP: return "LL_GEP";
-    case ir::OperationKind::LL_RETURN: return "LL_RETURN";
-    case ir::OperationKind::LL_SCOPE: return "LL_SCOPE";
-    case ir::OperationKind::LL_SCOPE_RECURSE: return "LL_SCOPE_RECURSE";
-    case ir::OperationKind::LL_SCOPE_RET: return "LL_SCOPE_RET";
-    case ir::OperationKind::LL_STORE: return "LL_STORE";
-    case ir::OperationKind::LL_SUBSCRIPT: return "LL_SUBSCRIPT";
-    case ir::OperationKind::LL_UNINITIALIZED_VAR: return "LL_UNINITIALIZED_VAR";
-    case ir::OperationKind::HL_ACCESS: return "HL_ACCESS";
-    case ir::OperationKind::HL_ASSIGN_FADD: return "HL_ASSIGN_FADD";
-    case ir::OperationKind::HL_FADD: return "HL_FADD";
-    case ir::OperationKind::HL_ASSIGN_ADD: return "HL_ASSIGN_ADD";
-    case ir::OperationKind::HL_ADD: return "HL_ADD";
-    case ir::OperationKind::HL_LABELADDR: return "HL_LABELADDR";
-    case ir::OperationKind::HL_ADDRESSOF: return "HL_ADDRESSOF";
-    case ir::OperationKind::HL_ALIGNOF_EXPR: return "HL_ALIGNOF_EXPR";
-    case ir::OperationKind::HL_ALIGNOF_TYPE: return "HL_ALIGNOF_TYPE";
-    case ir::OperationKind::HL_ASM: return "HL_ASM";
-    case ir::OperationKind::HL_ASSIGN: return "HL_ASSIGN";
-    case ir::OperationKind::HL_ATTRIBUTED_STMT: return "HL_ATTRIBUTED_STMT";
-    case ir::OperationKind::HL_ASSIGN_BIN_ASHR: return "HL_ASSIGN_BIN_ASHR";
-    case ir::OperationKind::HL_BIN_ASHR: return "HL_BIN_ASHR";
-    case ir::OperationKind::HL_ASSIGN_BIN_AND: return "HL_ASSIGN_BIN_AND";
-    case ir::OperationKind::HL_BIN_AND: return "HL_BIN_AND";
-    case ir::OperationKind::HL_BIN_COMMA: return "HL_BIN_COMMA";
-    case ir::OperationKind::HL_BIN_LAND: return "HL_BIN_LAND";
-    case ir::OperationKind::HL_BIN_LOR: return "HL_BIN_LOR";
-    case ir::OperationKind::HL_ASSIGN_BIN_LSHR: return "HL_ASSIGN_BIN_LSHR";
-    case ir::OperationKind::HL_BIN_LSHR: return "HL_BIN_LSHR";
-    case ir::OperationKind::HL_ASSIGN_BIN_OR: return "HL_ASSIGN_BIN_OR";
-    case ir::OperationKind::HL_BIN_OR: return "HL_BIN_OR";
-    case ir::OperationKind::HL_ASSIGN_BIN_SHL: return "HL_ASSIGN_BIN_SHL";
-    case ir::OperationKind::HL_BIN_SHL: return "HL_BIN_SHL";
-    case ir::OperationKind::HL_ASSIGN_BIN_XOR: return "HL_ASSIGN_BIN_XOR";
-    case ir::OperationKind::HL_BIN_XOR: return "HL_BIN_XOR";
-    case ir::OperationKind::HL_BINARY_COND: return "HL_BINARY_COND";
-    case ir::OperationKind::HL_BREAK: return "HL_BREAK";
-    case ir::OperationKind::HL_BUILTIN_BITCAST: return "HL_BUILTIN_BITCAST";
-    case ir::OperationKind::HL_BUILTIN_TYPES_COMPATIBLE_P_TYPE: return "HL_BUILTIN_TYPES_COMPATIBLE_P_TYPE";
-    case ir::OperationKind::HL_CSTYLE_CAST: return "HL_CSTYLE_CAST";
-    case ir::OperationKind::HL_CALL: return "HL_CALL";
-    case ir::OperationKind::HL_CASE: return "HL_CASE";
-    case ir::OperationKind::HL_CHOOSE_EXPR: return "HL_CHOOSE_EXPR";
-    case ir::OperationKind::HL_CLASS: return "HL_CLASS";
-    case ir::OperationKind::HL_CMP: return "HL_CMP";
-    case ir::OperationKind::HL_COMPOUND_LITERAL: return "HL_COMPOUND_LITERAL";
-    case ir::OperationKind::HL_COND: return "HL_COND";
-    case ir::OperationKind::HL_COND_YIELD: return "HL_COND_YIELD";
-    case ir::OperationKind::HL_CONST: return "HL_CONST";
-    case ir::OperationKind::HL_CONTINUE: return "HL_CONTINUE";
-    case ir::OperationKind::HL_BASE: return "HL_BASE";
-    case ir::OperationKind::HL_CXXSTRUCT: return "HL_CXXSTRUCT";
-    case ir::OperationKind::HL_REF: return "HL_REF";
-    case ir::OperationKind::HL_DEFAULT: return "HL_DEFAULT";
-    case ir::OperationKind::HL_DEREF: return "HL_DEREF";
-    case ir::OperationKind::HL_ASSIGN_FDIV: return "HL_ASSIGN_FDIV";
-    case ir::OperationKind::HL_FDIV: return "HL_FDIV";
-    case ir::OperationKind::HL_ASSIGN_SDIV: return "HL_ASSIGN_SDIV";
-    case ir::OperationKind::HL_SDIV: return "HL_SDIV";
-    case ir::OperationKind::HL_ASSIGN_UDIV: return "HL_ASSIGN_UDIV";
-    case ir::OperationKind::HL_UDIV: return "HL_UDIV";
-    case ir::OperationKind::HL_DO: return "HL_DO";
-    case ir::OperationKind::HL_EMPTY_DECL: return "HL_EMPTY_DECL";
-    case ir::OperationKind::HL_ENUM_CONST: return "HL_ENUM_CONST";
-    case ir::OperationKind::HL_ENUM: return "HL_ENUM";
-    case ir::OperationKind::HL_ENUMREF: return "HL_ENUMREF";
-    case ir::OperationKind::HL_EXPR: return "HL_EXPR";
-    case ir::OperationKind::HL_GNU_EXTENSION: return "HL_GNU_EXTENSION";
-    case ir::OperationKind::HL_FCMP: return "HL_FCMP";
-    case ir::OperationKind::HL_FIELD: return "HL_FIELD";
-    case ir::OperationKind::HL_FILE_SCOPE_ASM: return "HL_FILE_SCOPE_ASM";
-    case ir::OperationKind::HL_FOR: return "HL_FOR";
-    case ir::OperationKind::HL_FUNC: return "HL_FUNC";
-    case ir::OperationKind::HL_FUNCREF: return "HL_FUNCREF";
-    case ir::OperationKind::HL_GENERIC_ASOC: return "HL_GENERIC_ASOC";
-    case ir::OperationKind::HL_GENERIC_EXPR: return "HL_GENERIC_EXPR";
-    case ir::OperationKind::HL_GLOBREF: return "HL_GLOBREF";
-    case ir::OperationKind::HL_GOTO: return "HL_GOTO";
-    case ir::OperationKind::HL_IF: return "HL_IF";
-    case ir::OperationKind::HL_IMAG: return "HL_IMAG";
-    case ir::OperationKind::HL_IMPLICIT_CAST: return "HL_IMPLICIT_CAST";
-    case ir::OperationKind::HL_INDIRECT_CALL: return "HL_INDIRECT_CALL";
-    case ir::OperationKind::HL_INDIRECT_GOTO: return "HL_INDIRECT_GOTO";
-    case ir::OperationKind::HL_INITLIST: return "HL_INITLIST";
-    case ir::OperationKind::HL_CONST_INIT: return "HL_CONST_INIT";
-    case ir::OperationKind::HL_LNOT: return "HL_LNOT";
-    case ir::OperationKind::HL_LABEL_DECL: return "HL_LABEL_DECL";
-    case ir::OperationKind::HL_LABEL: return "HL_LABEL";
-    case ir::OperationKind::HL_MINUS: return "HL_MINUS";
-    case ir::OperationKind::HL_ASSIGN_FMUL: return "HL_ASSIGN_FMUL";
-    case ir::OperationKind::HL_FMUL: return "HL_FMUL";
-    case ir::OperationKind::HL_ASSIGN_MUL: return "HL_ASSIGN_MUL";
-    case ir::OperationKind::HL_MUL: return "HL_MUL";
-    case ir::OperationKind::HL_NOT: return "HL_NOT";
-    case ir::OperationKind::HL_NULL: return "HL_NULL";
-    case ir::OperationKind::HL_OFFSETOF_EXPR: return "HL_OFFSETOF_EXPR";
-    case ir::OperationKind::HL_OPAQUE_EXPR: return "HL_OPAQUE_EXPR";
-    case ir::OperationKind::HL_PLUS: return "HL_PLUS";
-    case ir::OperationKind::HL_POST_DEC: return "HL_POST_DEC";
-    case ir::OperationKind::HL_POST_INC: return "HL_POST_INC";
-    case ir::OperationKind::HL_PRE_DEC: return "HL_PRE_DEC";
-    case ir::OperationKind::HL_PRE_INC: return "HL_PRE_INC";
-    case ir::OperationKind::HL_PREDEFINED_EXPR: return "HL_PREDEFINED_EXPR";
-    case ir::OperationKind::HL_PREFERRED_ALIGNOF_EXPR: return "HL_PREFERRED_ALIGNOF_EXPR";
-    case ir::OperationKind::HL_PREFERRED_ALIGNOF_TYPE: return "HL_PREFERRED_ALIGNOF_TYPE";
-    case ir::OperationKind::HL_REAL: return "HL_REAL";
-    case ir::OperationKind::HL_MEMBER: return "HL_MEMBER";
-    case ir::OperationKind::HL_ASSIGN_FREM: return "HL_ASSIGN_FREM";
-    case ir::OperationKind::HL_FREM: return "HL_FREM";
-    case ir::OperationKind::HL_ASSIGN_SREM: return "HL_ASSIGN_SREM";
-    case ir::OperationKind::HL_SREM: return "HL_SREM";
-    case ir::OperationKind::HL_ASSIGN_UREM: return "HL_ASSIGN_UREM";
-    case ir::OperationKind::HL_UREM: return "HL_UREM";
-    case ir::OperationKind::HL_RETURN: return "HL_RETURN";
-    case ir::OperationKind::HL_SIZEOF_EXPR: return "HL_SIZEOF_EXPR";
-    case ir::OperationKind::HL_SIZEOF_TYPE: return "HL_SIZEOF_TYPE";
-    case ir::OperationKind::HL_STATIC_ASSERT: return "HL_STATIC_ASSERT";
-    case ir::OperationKind::HL_STMT_EXPR: return "HL_STMT_EXPR";
-    case ir::OperationKind::HL_STRUCT: return "HL_STRUCT";
-    case ir::OperationKind::HL_ASSIGN_FSUB: return "HL_ASSIGN_FSUB";
-    case ir::OperationKind::HL_FSUB: return "HL_FSUB";
-    case ir::OperationKind::HL_ASSIGN_SUB: return "HL_ASSIGN_SUB";
-    case ir::OperationKind::HL_SUB: return "HL_SUB";
-    case ir::OperationKind::HL_SUBSCRIPT: return "HL_SUBSCRIPT";
-    case ir::OperationKind::HL_SWITCH: return "HL_SWITCH";
-    case ir::OperationKind::HL_THIS: return "HL_THIS";
-    case ir::OperationKind::HL_TRANSLATION_UNIT: return "HL_TRANSLATION_UNIT";
-    case ir::OperationKind::HL_ALIAS: return "HL_ALIAS";
-    case ir::OperationKind::HL_TYPE: return "HL_TYPE";
-    case ir::OperationKind::HL_TYPEDEF: return "HL_TYPEDEF";
-    case ir::OperationKind::HL_TYPEOF_EXPR: return "HL_TYPEOF_EXPR";
-    case ir::OperationKind::HL_TYPE_YIELD: return "HL_TYPE_YIELD";
-    case ir::OperationKind::HL_UNION: return "HL_UNION";
-    case ir::OperationKind::HL_UNREACHABLE: return "HL_UNREACHABLE";
-    case ir::OperationKind::HL_VA_ARG_EXPR: return "HL_VA_ARG_EXPR";
-    case ir::OperationKind::HL_VALUE_YIELD: return "HL_VALUE_YIELD";
-    case ir::OperationKind::HL_VAR: return "HL_VAR";
-    case ir::OperationKind::HL_WHILE: return "HL_WHILE";
-    case ir::OperationKind::CORE_BIN_LAND: return "CORE_BIN_LAND";
-    case ir::OperationKind::CORE_BIN_LOR: return "CORE_BIN_LOR";
-    case ir::OperationKind::CORE_IMPLICIT_RETURN: return "CORE_IMPLICIT_RETURN";
-    case ir::OperationKind::CORE_LAZY_OP: return "CORE_LAZY_OP";
-    case ir::OperationKind::CORE_MODULE: return "CORE_MODULE";
-    case ir::OperationKind::CORE_SCOPE: return "CORE_SCOPE";
-    case ir::OperationKind::CORE_SELECT: return "CORE_SELECT";
-    case ir::OperationKind::UNSUP_DECL: return "UNSUP_DECL";
-    case ir::OperationKind::UNSUP_STMT: return "UNSUP_STMT";
-  }
-}
-
-bool IsBuiltinOperationKind(ir::OperationKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::OperationKind::BUILTIN_MODULE:
-    case mx::ir::OperationKind::BUILTIN_UNREALIZED_CONVERSION_CAST:
-      return true;
-  }
-}
-
-bool IsLLVMIROperationKind(ir::OperationKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::OperationKind::LLVM_ASHR:
-    case mx::ir::OperationKind::LLVM_ADD:
-    case mx::ir::OperationKind::LLVM_ADDRSPACECAST:
-    case mx::ir::OperationKind::LLVM_MLIR_ADDRESSOF:
-    case mx::ir::OperationKind::LLVM_ALLOCA:
-    case mx::ir::OperationKind::LLVM_AND:
-    case mx::ir::OperationKind::LLVM_CMPXCHG:
-    case mx::ir::OperationKind::LLVM_ATOMICRMW:
-    case mx::ir::OperationKind::LLVM_BITCAST:
-    case mx::ir::OperationKind::LLVM_BR:
-    case mx::ir::OperationKind::LLVM_CALL_INTRINSIC:
-    case mx::ir::OperationKind::LLVM_CALL:
-    case mx::ir::OperationKind::LLVM_COMDAT:
-    case mx::ir::OperationKind::LLVM_COMDAT_SELECTOR:
-    case mx::ir::OperationKind::LLVM_COND_BR:
-    case mx::ir::OperationKind::LLVM_MLIR_CONSTANT:
-    case mx::ir::OperationKind::LLVM_EXTRACTELEMENT:
-    case mx::ir::OperationKind::LLVM_EXTRACTVALUE:
-    case mx::ir::OperationKind::LLVM_FADD:
-    case mx::ir::OperationKind::LLVM_FCMP:
-    case mx::ir::OperationKind::LLVM_FDIV:
-    case mx::ir::OperationKind::LLVM_FMUL:
-    case mx::ir::OperationKind::LLVM_FNEG:
-    case mx::ir::OperationKind::LLVM_FPEXT:
-    case mx::ir::OperationKind::LLVM_FPTOSI:
-    case mx::ir::OperationKind::LLVM_FPTOUI:
-    case mx::ir::OperationKind::LLVM_FPTRUNC:
-    case mx::ir::OperationKind::LLVM_FREM:
-    case mx::ir::OperationKind::LLVM_FSUB:
-    case mx::ir::OperationKind::LLVM_FENCE:
-    case mx::ir::OperationKind::LLVM_FREEZE:
-    case mx::ir::OperationKind::LLVM_GETELEMENTPTR:
-    case mx::ir::OperationKind::LLVM_MLIR_GLOBAL_CTORS:
-    case mx::ir::OperationKind::LLVM_MLIR_GLOBAL_DTORS:
-    case mx::ir::OperationKind::LLVM_MLIR_GLOBAL:
-    case mx::ir::OperationKind::LLVM_ICMP:
-    case mx::ir::OperationKind::LLVM_INLINE_ASM:
-    case mx::ir::OperationKind::LLVM_INSERTELEMENT:
-    case mx::ir::OperationKind::LLVM_INSERTVALUE:
-    case mx::ir::OperationKind::LLVM_INTTOPTR:
-    case mx::ir::OperationKind::LLVM_INVOKE:
-    case mx::ir::OperationKind::LLVM_FUNC:
-    case mx::ir::OperationKind::LLVM_LSHR:
-    case mx::ir::OperationKind::LLVM_LANDINGPAD:
-    case mx::ir::OperationKind::LLVM_LINKER_OPTIONS:
-    case mx::ir::OperationKind::LLVM_LOAD:
-    case mx::ir::OperationKind::LLVM_MUL:
-    case mx::ir::OperationKind::LLVM_MLIR_NONE:
-    case mx::ir::OperationKind::LLVM_OR:
-    case mx::ir::OperationKind::LLVM_MLIR_POISON:
-    case mx::ir::OperationKind::LLVM_PTRTOINT:
-    case mx::ir::OperationKind::LLVM_RESUME:
-    case mx::ir::OperationKind::LLVM_RETURN:
-    case mx::ir::OperationKind::LLVM_SDIV:
-    case mx::ir::OperationKind::LLVM_SEXT:
-    case mx::ir::OperationKind::LLVM_SITOFP:
-    case mx::ir::OperationKind::LLVM_SREM:
-    case mx::ir::OperationKind::LLVM_SELECT:
-    case mx::ir::OperationKind::LLVM_SHL:
-    case mx::ir::OperationKind::LLVM_SHUFFLEVECTOR:
-    case mx::ir::OperationKind::LLVM_STORE:
-    case mx::ir::OperationKind::LLVM_SUB:
-    case mx::ir::OperationKind::LLVM_SWITCH:
-    case mx::ir::OperationKind::LLVM_TRUNC:
-    case mx::ir::OperationKind::LLVM_UDIV:
-    case mx::ir::OperationKind::LLVM_UITOFP:
-    case mx::ir::OperationKind::LLVM_UREM:
-    case mx::ir::OperationKind::LLVM_MLIR_UNDEF:
-    case mx::ir::OperationKind::LLVM_UNREACHABLE:
-    case mx::ir::OperationKind::LLVM_XOR:
-    case mx::ir::OperationKind::LLVM_ZEXT:
-    case mx::ir::OperationKind::LLVM_MLIR_ZERO:
-    case mx::ir::OperationKind::LLVM_INTR_ABS:
-    case mx::ir::OperationKind::LLVM_INTR_ANNOTATION:
-    case mx::ir::OperationKind::LLVM_INTR_ASSUME:
-    case mx::ir::OperationKind::LLVM_INTR_BITREVERSE:
-    case mx::ir::OperationKind::LLVM_INTR_BSWAP:
-    case mx::ir::OperationKind::LLVM_INTR_COPYSIGN:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_ALIGN:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_BEGIN:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_END:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_FREE:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_ID:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_PROMISE:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_RESUME:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_SAVE:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_SIZE:
-    case mx::ir::OperationKind::LLVM_INTR_CORO_SUSPEND:
-    case mx::ir::OperationKind::LLVM_INTR_COS:
-    case mx::ir::OperationKind::LLVM_INTR_CTLZ:
-    case mx::ir::OperationKind::LLVM_INTR_CTTZ:
-    case mx::ir::OperationKind::LLVM_INTR_CTPOP:
-    case mx::ir::OperationKind::LLVM_INTR_DBG_DECLARE:
-    case mx::ir::OperationKind::LLVM_INTR_DBG_LABEL:
-    case mx::ir::OperationKind::LLVM_INTR_DBG_VALUE:
-    case mx::ir::OperationKind::LLVM_INTR_DEBUGTRAP:
-    case mx::ir::OperationKind::LLVM_INTR_EH_TYPEID_FOR:
-    case mx::ir::OperationKind::LLVM_INTR_EXP2:
-    case mx::ir::OperationKind::LLVM_INTR_EXP:
-    case mx::ir::OperationKind::LLVM_INTR_EXPECT:
-    case mx::ir::OperationKind::LLVM_INTR_EXPECT_WITH_PROBABILITY:
-    case mx::ir::OperationKind::LLVM_INTR_FABS:
-    case mx::ir::OperationKind::LLVM_INTR_CEIL:
-    case mx::ir::OperationKind::LLVM_INTR_FLOOR:
-    case mx::ir::OperationKind::LLVM_INTR_FMA:
-    case mx::ir::OperationKind::LLVM_INTR_FMULADD:
-    case mx::ir::OperationKind::LLVM_INTR_TRUNC:
-    case mx::ir::OperationKind::LLVM_INTR_FSHL:
-    case mx::ir::OperationKind::LLVM_INTR_FSHR:
-    case mx::ir::OperationKind::LLVM_INTR_GET_ACTIVE_LANE_MASK:
-    case mx::ir::OperationKind::LLVM_INTR_INVARIANT_END:
-    case mx::ir::OperationKind::LLVM_INTR_INVARIANT_START:
-    case mx::ir::OperationKind::LLVM_INTR_IS_CONSTANT:
-    case mx::ir::OperationKind::LLVM_INTR_IS_FPCLASS:
-    case mx::ir::OperationKind::LLVM_INTR_LIFETIME_END:
-    case mx::ir::OperationKind::LLVM_INTR_LIFETIME_START:
-    case mx::ir::OperationKind::LLVM_INTR_LLRINT:
-    case mx::ir::OperationKind::LLVM_INTR_LLROUND:
-    case mx::ir::OperationKind::LLVM_INTR_LOG10:
-    case mx::ir::OperationKind::LLVM_INTR_LOG2:
-    case mx::ir::OperationKind::LLVM_INTR_LOG:
-    case mx::ir::OperationKind::LLVM_INTR_LRINT:
-    case mx::ir::OperationKind::LLVM_INTR_LROUND:
-    case mx::ir::OperationKind::LLVM_INTR_MASKED_LOAD:
-    case mx::ir::OperationKind::LLVM_INTR_MASKED_STORE:
-    case mx::ir::OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_LOAD:
-    case mx::ir::OperationKind::LLVM_INTR_MATRIX_COLUMN_MAJOR_STORE:
-    case mx::ir::OperationKind::LLVM_INTR_MATRIX_MULTIPLY:
-    case mx::ir::OperationKind::LLVM_INTR_MATRIX_TRANSPOSE:
-    case mx::ir::OperationKind::LLVM_INTR_MAXNUM:
-    case mx::ir::OperationKind::LLVM_INTR_MAXIMUM:
-    case mx::ir::OperationKind::LLVM_INTR_MEMCPY_INLINE:
-    case mx::ir::OperationKind::LLVM_INTR_MEMCPY:
-    case mx::ir::OperationKind::LLVM_INTR_MEMMOVE:
-    case mx::ir::OperationKind::LLVM_INTR_MEMSET:
-    case mx::ir::OperationKind::LLVM_INTR_MINNUM:
-    case mx::ir::OperationKind::LLVM_INTR_MINIMUM:
-    case mx::ir::OperationKind::LLVM_INTR_NEARBYINT:
-    case mx::ir::OperationKind::LLVM_INTR_EXPERIMENTAL_NOALIAS_SCOPE_DECL:
-    case mx::ir::OperationKind::LLVM_INTR_POWI:
-    case mx::ir::OperationKind::LLVM_INTR_POW:
-    case mx::ir::OperationKind::LLVM_INTR_PREFETCH:
-    case mx::ir::OperationKind::LLVM_INTR_PTR_ANNOTATION:
-    case mx::ir::OperationKind::LLVM_INTR_RINT:
-    case mx::ir::OperationKind::LLVM_INTR_ROUNDEVEN:
-    case mx::ir::OperationKind::LLVM_INTR_ROUND:
-    case mx::ir::OperationKind::LLVM_INTR_SADD_SAT:
-    case mx::ir::OperationKind::LLVM_INTR_SADD_WITH_OVERFLOW:
-    case mx::ir::OperationKind::LLVM_INTR_SMAX:
-    case mx::ir::OperationKind::LLVM_INTR_SMIN:
-    case mx::ir::OperationKind::LLVM_INTR_SMUL_WITH_OVERFLOW:
-    case mx::ir::OperationKind::LLVM_INTR_SSA_COPY:
-    case mx::ir::OperationKind::LLVM_INTR_SSHL_SAT:
-    case mx::ir::OperationKind::LLVM_INTR_SSUB_SAT:
-    case mx::ir::OperationKind::LLVM_INTR_SSUB_WITH_OVERFLOW:
-    case mx::ir::OperationKind::LLVM_INTR_SIN:
-    case mx::ir::OperationKind::LLVM_INTR_SQRT:
-    case mx::ir::OperationKind::LLVM_INTR_STACKRESTORE:
-    case mx::ir::OperationKind::LLVM_INTR_STACKSAVE:
-    case mx::ir::OperationKind::LLVM_INTR_EXPERIMENTAL_STEPVECTOR:
-    case mx::ir::OperationKind::LLVM_INTR_THREADLOCAL_ADDRESS:
-    case mx::ir::OperationKind::LLVM_INTR_TRAP:
-    case mx::ir::OperationKind::LLVM_INTR_UADD_SAT:
-    case mx::ir::OperationKind::LLVM_INTR_UADD_WITH_OVERFLOW:
-    case mx::ir::OperationKind::LLVM_INTR_UBSANTRAP:
-    case mx::ir::OperationKind::LLVM_INTR_UMAX:
-    case mx::ir::OperationKind::LLVM_INTR_UMIN:
-    case mx::ir::OperationKind::LLVM_INTR_UMUL_WITH_OVERFLOW:
-    case mx::ir::OperationKind::LLVM_INTR_USHL_SAT:
-    case mx::ir::OperationKind::LLVM_INTR_USUB_SAT:
-    case mx::ir::OperationKind::LLVM_INTR_USUB_WITH_OVERFLOW:
-    case mx::ir::OperationKind::LLVM_INTR_VP_ASHR:
-    case mx::ir::OperationKind::LLVM_INTR_VP_ADD:
-    case mx::ir::OperationKind::LLVM_INTR_VP_AND:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FADD:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FDIV:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FMULADD:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FMUL:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FNEG:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FPEXT:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FPTOSI:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FPTOUI:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FPTRUNC:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FREM:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FSUB:
-    case mx::ir::OperationKind::LLVM_INTR_VP_FMA:
-    case mx::ir::OperationKind::LLVM_INTR_VP_INTTOPTR:
-    case mx::ir::OperationKind::LLVM_INTR_VP_LSHR:
-    case mx::ir::OperationKind::LLVM_INTR_VP_LOAD:
-    case mx::ir::OperationKind::LLVM_INTR_VP_MERGE:
-    case mx::ir::OperationKind::LLVM_INTR_VP_MUL:
-    case mx::ir::OperationKind::LLVM_INTR_VP_OR:
-    case mx::ir::OperationKind::LLVM_INTR_VP_PTRTOINT:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_ADD:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_AND:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_FADD:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_FMAX:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_FMIN:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_FMUL:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_MUL:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_OR:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_SMAX:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_SMIN:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_UMAX:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_UMIN:
-    case mx::ir::OperationKind::LLVM_INTR_VP_REDUCE_XOR:
-    case mx::ir::OperationKind::LLVM_INTR_VP_SDIV:
-    case mx::ir::OperationKind::LLVM_INTR_VP_SEXT:
-    case mx::ir::OperationKind::LLVM_INTR_VP_SITOFP:
-    case mx::ir::OperationKind::LLVM_INTR_VP_SREM:
-    case mx::ir::OperationKind::LLVM_INTR_VP_SELECT:
-    case mx::ir::OperationKind::LLVM_INTR_VP_SHL:
-    case mx::ir::OperationKind::LLVM_INTR_VP_STORE:
-    case mx::ir::OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_LOAD:
-    case mx::ir::OperationKind::LLVM_INTR_EXPERIMENTAL_VP_STRIDED_STORE:
-    case mx::ir::OperationKind::LLVM_INTR_VP_SUB:
-    case mx::ir::OperationKind::LLVM_INTR_VP_TRUNC:
-    case mx::ir::OperationKind::LLVM_INTR_VP_UDIV:
-    case mx::ir::OperationKind::LLVM_INTR_VP_UITOFP:
-    case mx::ir::OperationKind::LLVM_INTR_VP_UREM:
-    case mx::ir::OperationKind::LLVM_INTR_VP_XOR:
-    case mx::ir::OperationKind::LLVM_INTR_VP_ZEXT:
-    case mx::ir::OperationKind::LLVM_INTR_VACOPY:
-    case mx::ir::OperationKind::LLVM_INTR_VAEND:
-    case mx::ir::OperationKind::LLVM_INTR_VASTART:
-    case mx::ir::OperationKind::LLVM_INTR_VAR_ANNOTATION:
-    case mx::ir::OperationKind::LLVM_INTR_MASKED_COMPRESSSTORE:
-    case mx::ir::OperationKind::LLVM_INTR_MASKED_EXPANDLOAD:
-    case mx::ir::OperationKind::LLVM_INTR_MASKED_GATHER:
-    case mx::ir::OperationKind::LLVM_INTR_MASKED_SCATTER:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_EXTRACT:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_INSERT:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_ADD:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_AND:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FADD:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAX:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMAXIMUM:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMIN:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMINIMUM:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_FMUL:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_MUL:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_OR:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_SMAX:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_SMIN:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_UMAX:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_UMIN:
-    case mx::ir::OperationKind::LLVM_INTR_VECTOR_REDUCE_XOR:
-    case mx::ir::OperationKind::LLVM_INTR_VSCALE:
-      return true;
-  }
-}
-
-bool IsMemRefOperationKind(ir::OperationKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::OperationKind::MEMREF_ASSUME_ALIGNMENT:
-    case mx::ir::OperationKind::MEMREF_ATOMIC_RMW:
-    case mx::ir::OperationKind::MEMREF_ATOMIC_YIELD:
-    case mx::ir::OperationKind::MEMREF_COPY:
-    case mx::ir::OperationKind::MEMREF_GENERIC_ATOMIC_RMW:
-    case mx::ir::OperationKind::MEMREF_LOAD:
-    case mx::ir::OperationKind::MEMREF_ALLOC:
-    case mx::ir::OperationKind::MEMREF_ALLOCA:
-    case mx::ir::OperationKind::MEMREF_ALLOCA_SCOPE:
-    case mx::ir::OperationKind::MEMREF_ALLOCA_SCOPE_RETURN:
-    case mx::ir::OperationKind::MEMREF_CAST:
-    case mx::ir::OperationKind::MEMREF_COLLAPSE_SHAPE:
-    case mx::ir::OperationKind::MEMREF_DEALLOC:
-    case mx::ir::OperationKind::MEMREF_DIM:
-    case mx::ir::OperationKind::MEMREF_DMA_START:
-    case mx::ir::OperationKind::MEMREF_DMA_WAIT:
-    case mx::ir::OperationKind::MEMREF_EXPAND_SHAPE:
-    case mx::ir::OperationKind::MEMREF_EXTRACT_ALIGNED_POINTER_AS_INDEX:
-    case mx::ir::OperationKind::MEMREF_EXTRACT_STRIDED_METADATA:
-    case mx::ir::OperationKind::MEMREF_GET_GLOBAL:
-    case mx::ir::OperationKind::MEMREF_GLOBAL:
-    case mx::ir::OperationKind::MEMREF_MEMORY_SPACE_CAST:
-    case mx::ir::OperationKind::MEMREF_PREFETCH:
-    case mx::ir::OperationKind::MEMREF_RANK:
-    case mx::ir::OperationKind::MEMREF_REALLOC:
-    case mx::ir::OperationKind::MEMREF_REINTERPRET_CAST:
-    case mx::ir::OperationKind::MEMREF_RESHAPE:
-    case mx::ir::OperationKind::MEMREF_STORE:
-    case mx::ir::OperationKind::MEMREF_TRANSPOSE:
-    case mx::ir::OperationKind::MEMREF_VIEW:
-    case mx::ir::OperationKind::MEMREF_SUBVIEW:
-      return true;
-  }
-}
-
-bool IsABIOperationKind(ir::OperationKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::OperationKind::ABI_CALL_ARGS:
-    case mx::ir::OperationKind::ABI_CALL_EXEC:
-    case mx::ir::OperationKind::ABI_CALL:
-    case mx::ir::OperationKind::ABI_CALL_RETS:
-    case mx::ir::OperationKind::ABI_DIRECT:
-    case mx::ir::OperationKind::ABI_EPILOGUE:
-    case mx::ir::OperationKind::ABI_FUNC:
-    case mx::ir::OperationKind::ABI_INDIRECT:
-    case mx::ir::OperationKind::ABI_PROLOGUE:
-    case mx::ir::OperationKind::ABI_RET_DIRECT:
-    case mx::ir::OperationKind::ABI_YIELD:
-      return true;
-  }
-}
-
-bool IsLowLevelOperationKind(ir::OperationKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::OperationKind::LL_ALLOCA:
-    case mx::ir::OperationKind::LL_ARG_ALLOCA:
-    case mx::ir::OperationKind::LL_BR:
-    case mx::ir::OperationKind::LL_CONCAT:
-    case mx::ir::OperationKind::LL_COND_BR:
-    case mx::ir::OperationKind::LL_COND_SCOPE_RET:
-    case mx::ir::OperationKind::LL_EXTRACT:
-    case mx::ir::OperationKind::LL_INITIALIZE:
-    case mx::ir::OperationKind::LL_INLINE_SCOPE:
-    case mx::ir::OperationKind::LL_LOAD:
-    case mx::ir::OperationKind::LL_FUNC:
-    case mx::ir::OperationKind::LL_GEP:
-    case mx::ir::OperationKind::LL_RETURN:
-    case mx::ir::OperationKind::LL_SCOPE:
-    case mx::ir::OperationKind::LL_SCOPE_RECURSE:
-    case mx::ir::OperationKind::LL_SCOPE_RET:
-    case mx::ir::OperationKind::LL_STORE:
-    case mx::ir::OperationKind::LL_SUBSCRIPT:
-    case mx::ir::OperationKind::LL_UNINITIALIZED_VAR:
-      return true;
-  }
-}
-
-bool IsHighLevelOperationKind(ir::OperationKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::OperationKind::HL_ACCESS:
-    case mx::ir::OperationKind::HL_ASSIGN_FADD:
-    case mx::ir::OperationKind::HL_FADD:
-    case mx::ir::OperationKind::HL_ASSIGN_ADD:
-    case mx::ir::OperationKind::HL_ADD:
-    case mx::ir::OperationKind::HL_LABELADDR:
-    case mx::ir::OperationKind::HL_ADDRESSOF:
-    case mx::ir::OperationKind::HL_ALIGNOF_EXPR:
-    case mx::ir::OperationKind::HL_ALIGNOF_TYPE:
-    case mx::ir::OperationKind::HL_ASM:
-    case mx::ir::OperationKind::HL_ASSIGN:
-    case mx::ir::OperationKind::HL_ATTRIBUTED_STMT:
-    case mx::ir::OperationKind::HL_ASSIGN_BIN_ASHR:
-    case mx::ir::OperationKind::HL_BIN_ASHR:
-    case mx::ir::OperationKind::HL_ASSIGN_BIN_AND:
-    case mx::ir::OperationKind::HL_BIN_AND:
-    case mx::ir::OperationKind::HL_BIN_COMMA:
-    case mx::ir::OperationKind::HL_BIN_LAND:
-    case mx::ir::OperationKind::HL_BIN_LOR:
-    case mx::ir::OperationKind::HL_ASSIGN_BIN_LSHR:
-    case mx::ir::OperationKind::HL_BIN_LSHR:
-    case mx::ir::OperationKind::HL_ASSIGN_BIN_OR:
-    case mx::ir::OperationKind::HL_BIN_OR:
-    case mx::ir::OperationKind::HL_ASSIGN_BIN_SHL:
-    case mx::ir::OperationKind::HL_BIN_SHL:
-    case mx::ir::OperationKind::HL_ASSIGN_BIN_XOR:
-    case mx::ir::OperationKind::HL_BIN_XOR:
-    case mx::ir::OperationKind::HL_BINARY_COND:
-    case mx::ir::OperationKind::HL_BREAK:
-    case mx::ir::OperationKind::HL_BUILTIN_BITCAST:
-    case mx::ir::OperationKind::HL_BUILTIN_TYPES_COMPATIBLE_P_TYPE:
-    case mx::ir::OperationKind::HL_CSTYLE_CAST:
-    case mx::ir::OperationKind::HL_CALL:
-    case mx::ir::OperationKind::HL_CASE:
-    case mx::ir::OperationKind::HL_CHOOSE_EXPR:
-    case mx::ir::OperationKind::HL_CLASS:
-    case mx::ir::OperationKind::HL_CMP:
-    case mx::ir::OperationKind::HL_COMPOUND_LITERAL:
-    case mx::ir::OperationKind::HL_COND:
-    case mx::ir::OperationKind::HL_COND_YIELD:
-    case mx::ir::OperationKind::HL_CONST:
-    case mx::ir::OperationKind::HL_CONTINUE:
-    case mx::ir::OperationKind::HL_BASE:
-    case mx::ir::OperationKind::HL_CXXSTRUCT:
-    case mx::ir::OperationKind::HL_REF:
-    case mx::ir::OperationKind::HL_DEFAULT:
-    case mx::ir::OperationKind::HL_DEREF:
-    case mx::ir::OperationKind::HL_ASSIGN_FDIV:
-    case mx::ir::OperationKind::HL_FDIV:
-    case mx::ir::OperationKind::HL_ASSIGN_SDIV:
-    case mx::ir::OperationKind::HL_SDIV:
-    case mx::ir::OperationKind::HL_ASSIGN_UDIV:
-    case mx::ir::OperationKind::HL_UDIV:
-    case mx::ir::OperationKind::HL_DO:
-    case mx::ir::OperationKind::HL_EMPTY_DECL:
-    case mx::ir::OperationKind::HL_ENUM_CONST:
-    case mx::ir::OperationKind::HL_ENUM:
-    case mx::ir::OperationKind::HL_ENUMREF:
-    case mx::ir::OperationKind::HL_EXPR:
-    case mx::ir::OperationKind::HL_GNU_EXTENSION:
-    case mx::ir::OperationKind::HL_FCMP:
-    case mx::ir::OperationKind::HL_FIELD:
-    case mx::ir::OperationKind::HL_FILE_SCOPE_ASM:
-    case mx::ir::OperationKind::HL_FOR:
-    case mx::ir::OperationKind::HL_FUNC:
-    case mx::ir::OperationKind::HL_FUNCREF:
-    case mx::ir::OperationKind::HL_GENERIC_ASOC:
-    case mx::ir::OperationKind::HL_GENERIC_EXPR:
-    case mx::ir::OperationKind::HL_GLOBREF:
-    case mx::ir::OperationKind::HL_GOTO:
-    case mx::ir::OperationKind::HL_IF:
-    case mx::ir::OperationKind::HL_IMAG:
-    case mx::ir::OperationKind::HL_IMPLICIT_CAST:
-    case mx::ir::OperationKind::HL_INDIRECT_CALL:
-    case mx::ir::OperationKind::HL_INDIRECT_GOTO:
-    case mx::ir::OperationKind::HL_INITLIST:
-    case mx::ir::OperationKind::HL_CONST_INIT:
-    case mx::ir::OperationKind::HL_LNOT:
-    case mx::ir::OperationKind::HL_LABEL_DECL:
-    case mx::ir::OperationKind::HL_LABEL:
-    case mx::ir::OperationKind::HL_MINUS:
-    case mx::ir::OperationKind::HL_ASSIGN_FMUL:
-    case mx::ir::OperationKind::HL_FMUL:
-    case mx::ir::OperationKind::HL_ASSIGN_MUL:
-    case mx::ir::OperationKind::HL_MUL:
-    case mx::ir::OperationKind::HL_NOT:
-    case mx::ir::OperationKind::HL_NULL:
-    case mx::ir::OperationKind::HL_OFFSETOF_EXPR:
-    case mx::ir::OperationKind::HL_OPAQUE_EXPR:
-    case mx::ir::OperationKind::HL_PLUS:
-    case mx::ir::OperationKind::HL_POST_DEC:
-    case mx::ir::OperationKind::HL_POST_INC:
-    case mx::ir::OperationKind::HL_PRE_DEC:
-    case mx::ir::OperationKind::HL_PRE_INC:
-    case mx::ir::OperationKind::HL_PREDEFINED_EXPR:
-    case mx::ir::OperationKind::HL_PREFERRED_ALIGNOF_EXPR:
-    case mx::ir::OperationKind::HL_PREFERRED_ALIGNOF_TYPE:
-    case mx::ir::OperationKind::HL_REAL:
-    case mx::ir::OperationKind::HL_MEMBER:
-    case mx::ir::OperationKind::HL_ASSIGN_FREM:
-    case mx::ir::OperationKind::HL_FREM:
-    case mx::ir::OperationKind::HL_ASSIGN_SREM:
-    case mx::ir::OperationKind::HL_SREM:
-    case mx::ir::OperationKind::HL_ASSIGN_UREM:
-    case mx::ir::OperationKind::HL_UREM:
-    case mx::ir::OperationKind::HL_RETURN:
-    case mx::ir::OperationKind::HL_SIZEOF_EXPR:
-    case mx::ir::OperationKind::HL_SIZEOF_TYPE:
-    case mx::ir::OperationKind::HL_STATIC_ASSERT:
-    case mx::ir::OperationKind::HL_STMT_EXPR:
-    case mx::ir::OperationKind::HL_STRUCT:
-    case mx::ir::OperationKind::HL_ASSIGN_FSUB:
-    case mx::ir::OperationKind::HL_FSUB:
-    case mx::ir::OperationKind::HL_ASSIGN_SUB:
-    case mx::ir::OperationKind::HL_SUB:
-    case mx::ir::OperationKind::HL_SUBSCRIPT:
-    case mx::ir::OperationKind::HL_SWITCH:
-    case mx::ir::OperationKind::HL_THIS:
-    case mx::ir::OperationKind::HL_TRANSLATION_UNIT:
-    case mx::ir::OperationKind::HL_ALIAS:
-    case mx::ir::OperationKind::HL_TYPE:
-    case mx::ir::OperationKind::HL_TYPEDEF:
-    case mx::ir::OperationKind::HL_TYPEOF_EXPR:
-    case mx::ir::OperationKind::HL_TYPE_YIELD:
-    case mx::ir::OperationKind::HL_UNION:
-    case mx::ir::OperationKind::HL_UNREACHABLE:
-    case mx::ir::OperationKind::HL_VA_ARG_EXPR:
-    case mx::ir::OperationKind::HL_VALUE_YIELD:
-    case mx::ir::OperationKind::HL_VAR:
-    case mx::ir::OperationKind::HL_WHILE:
-      return true;
-  }
-}
-
-bool IsCoreOperationKind(ir::OperationKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::OperationKind::CORE_BIN_LAND:
-    case mx::ir::OperationKind::CORE_BIN_LOR:
-    case mx::ir::OperationKind::CORE_IMPLICIT_RETURN:
-    case mx::ir::OperationKind::CORE_LAZY_OP:
-    case mx::ir::OperationKind::CORE_MODULE:
-    case mx::ir::OperationKind::CORE_SCOPE:
-    case mx::ir::OperationKind::CORE_SELECT:
-      return true;
-  }
-}
-
-bool IsMetaOperationKind(ir::OperationKind kind) {
-  switch (kind) {
-    default:
-      return false;
-  }
-}
-
-bool IsUnsupportedOperationKind(ir::OperationKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::OperationKind::UNSUP_DECL:
-    case mx::ir::OperationKind::UNSUP_STMT:
-      return true;
-  }
-}
-
-}  // namespace mx
diff --git a/lib/IR/Region.cpp b/lib/IR/Region.cpp
deleted file mode 100644
index ef1cb53fa..000000000
--- a/lib/IR/Region.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#include <multiplier/IR/Region.h>
-
-#include <cassert>
-
-#include <mlir/IR/Block.h>
-#include <mlir/IR/Operation.h>
-#include <mlir/IR/Region.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Operation.h>
-
-#include "SourceIR.h"
-
-namespace mx::ir {
-
-const char *EnumeratorName(BasicBlockOrder val) {
-  switch (val) {
-    case BasicBlockOrder::PRE_ORDER: return "PRE_ORDER";
-    case BasicBlockOrder::POST_ORDER: return "POST_ORDER";
-    default: return "<invalid>";
-  }
-}
-
-Region::Region(std::shared_ptr<const SourceIRImpl> module,
-               mlir::Region *region)
-    : module_(std::move(module)),
-      region_(region) {
-  assert(region_ != nullptr);
-}
-
-Region Region::containing(const Block &block) {
-  return Region(block.module_, block.block_->getParent());
-}
-
-// In general, all operations are contained inside a region, except the
-// module operation.
-std::optional<Region> Region::containing(const Operation &op) {
-  if (mlir::Region *region = op.op_->getParentRegion()) {
-    return Region(op.module_, region);
-  }
-  return std::nullopt;
-}
-
-unsigned Region::num_blocks(void) const noexcept {
-  return static_cast<unsigned>(region_->getBlocks().size());
-}
-
-std::optional<Block> Region::nth_block(unsigned i) const noexcept {
-  for (mlir::Block &block : region_->getBlocks()) {
-    if (!i) {
-      return Block(module_, &block);
-    }
-
-    --i;
-  }
-
-  return std::nullopt;
-}
-
-gap::generator<Block> Region::blocks(void) const & noexcept {
-  for (mlir::Block &block : region_->getBlocks()) {
-    co_yield Block(module_, &block);
-  }
-}
-
-gap::generator<Block> Region::reverse_blocks(void) const & noexcept {
-  auto &blocks = region_->getBlocks();
-  for (auto it = blocks.rbegin(), end = blocks.rend(); it != end; ++it) {
-    co_yield Block(module_, &*it);
-  }
-}
-
-Block Region::entry_block(void) const noexcept {
-  return Block(module_, &(region_->front()));
-}
-
-unsigned Region::num_entry_block_arguments(void) const noexcept {
-  return static_cast<unsigned>(region_->front().getArguments().size());
-}
-
-std::optional<Argument>
-Region::nth_entry_block_argument(unsigned i) const noexcept {
-  if (auto args = region_->front().getArguments(); i < args.size()) {
-    return Argument(
-        module_,
-        reinterpret_cast<mlir::detail::BlockArgumentImpl *>(
-            args[i].getAsOpaquePointer()));
-  }
-  return std::nullopt;
-}
-
-gap::generator<Argument>
-Region::entry_block_arguments(void) const & noexcept {
-  for (mlir::BlockArgument arg : region_->front().getArguments()) {
-    co_yield Argument(
-        module_,
-        reinterpret_cast<mlir::detail::BlockArgumentImpl *>(
-            arg.getAsOpaquePointer()));
-  }
-}
-
-bool Region::operator==(const Region &that) const noexcept {
-  if (underlying_region() == that.underlying_region()) {
-    return true;
-  }
-
-  if (module_ == that.module_) {
-    return false;
-  }
-
-  if (region_->getRegionNumber() != that.region_->getRegionNumber()) {
-    return false;
-  }
-
-  return OperationIdsMatch(region_->getParentOp(), that.region_->getParentOp());
-}
-
-}  // namespace mx::ir
diff --git a/lib/IR/SourceIR.cpp b/lib/IR/SourceIR.cpp
deleted file mode 100644
index 5e393f820..000000000
--- a/lib/IR/SourceIR.cpp
+++ /dev/null
@@ -1,599 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#include "SourceIR.h"
-
-#include <cassert>
-#include <iostream>
-#include <unordered_map>
-
-#include <multiplier/AST/Attr.h>
-#include <multiplier/AST/Decl.h>
-#include <multiplier/AST/Designator.h>
-#include <multiplier/AST/PseudoKind.h>
-#include <multiplier/AST/Stmt.h>
-#include <multiplier/AST/Type.h>
-#include <multiplier/Frontend/Macro.h>
-#include <multiplier/IR/Attribute.h>
-#include <multiplier/IR/HighLevel/Operation.h>
-#include <multiplier/IR/Operation.h>
-#include <multiplier/IR/OperationKind.h>
-#include <multiplier/IR/Type.h>
-
-#include <llvm/ADT/DenseMap.h>
-#include <llvm/ADT/StringRef.h>
-#include <llvm/Support/SourceMgr.h>
-
-#include <mlir/Bytecode/BytecodeReader.h>
-#include <mlir/Dialect/SCF/IR/SCF.h>
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <mlir/Dialect/MemRef/IR/MemRef.h>
-#include <mlir/InitAllDialects.h>
-#include <mlir/IR/AttributeSupport.h>
-#include <mlir/IR/BuiltinOps.h>
-#include <mlir/IR/BuiltinTypes.h>
-#include <mlir/IR/BuiltinAttributes.h>
-#include <mlir/IR/DialectRegistry.h>
-#include <mlir/IR/TypeSupport.h>
-#include <mlir/IR/Visitors.h>
-#include <mlir/Parser/Parser.h>
-#include <mlir/Support/TypeID.h>
-
-#include <vast/Dialect/Core/CoreOps.hpp>
-#include <vast/Dialect/Core/CoreTypes.hpp>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/ABI/ABIOps.hpp>
-#include <vast/Dialect/HighLevel/HighLevelOps.hpp>
-#include <vast/Dialect/HighLevel/HighLevelTypes.hpp>
-#include <vast/Dialect/LowLevel/LowLevelOps.hpp>
-#include <vast/Dialect/Meta/MetaAttributes.hpp>
-#include <vast/Dialect/Meta/MetaTypes.hpp>
-#include <vast/Dialect/Unsupported/UnsupportedOps.hpp>
-#include <vast/Dialect/Unsupported/UnsupportedTypes.hpp>
-#include <vast/CodeGen/CodeGenBuilder.hpp>
-
-#include "../Compilation.h"
-#include "../Fragment.h"
-#include "Attribute.h"
-#include "Operation.h"
-#include "Type.h"
-
-namespace mx {
-namespace ir {
-namespace {
-
-// Get the entity id from the location. It is embedded as `meta.id<>`
-static RawEntityId MetaIdFromLocation(mlir::Location loc) {
-  if (loc.isa<mlir::FusedLoc>()) {
-    mlir::Attribute meta = loc.cast<mlir::FusedLoc>().getMetadata();
-    if (meta.isa<vast::meta::IdentifierAttr>()) {
-      return meta.cast<const vast::meta::IdentifierAttr>().getValue();
-    }
-  }
-  return kInvalidEntityId;
-}
-
-// Register all dialects.
-class MLIRRegistryInitializer {
- public:
-  explicit MLIRRegistryInitializer(mlir::DialectRegistry &registry) {
-    ::vast::registerAllDialects(registry);
-    ::mlir::registerAllDialects(registry);
-  }
-};
-
-class MLIRInitializer {
- private:
-  MLIRInitializer(void) = delete;
-
-  mlir::DialectRegistry registry;
-  MLIRRegistryInitializer registry_initializer;
-  mutable mlir::MLIRContext context;
-
- public:
-
-  llvm::DenseMap<llvm::StringRef, OperationKind> op_name_to_kind;
-  llvm::DenseMap<mlir::TypeID, OperationKind> op_type_to_kind;
-  llvm::DenseMap<mlir::TypeID, AttributeKind> attr_type_to_kind;
-  llvm::DenseMap<mlir::TypeID, TypeKind> type_type_to_kind;
-
-  explicit MLIRInitializer(int);
-
-  inline mlir::MLIRContext &Context(void) const noexcept {
-    return context;
-  }
-
-  ~MLIRInitializer(void);
-};
-
-MLIRInitializer::MLIRInitializer(int)
-    : registry(),
-      registry_initializer(registry),
-      context(registry, mlir::MLIRContext::Threading::ENABLED),
-      op_name_to_kind(MX_IR_NUM_MLIR_OPS),
-      op_type_to_kind(MX_IR_NUM_MLIR_OPS) {
-
-  context.disableMultithreading();
-  context.loadAllAvailableDialects();
-  context.enableMultithreading();
-
-  // Map all operation types.
-#define MAP_OP_NAME(name, kind, type) \
-    op_name_to_kind.try_emplace(name, kind);
-
-#define MAP_OP_TYPE(name, kind, type) \
-    op_type_to_kind.try_emplace(mlir::TypeID::get<type>(), kind);
-
-#define MAP_ATTR_TYPE(name, kind, type) \
-    attr_type_to_kind.try_emplace(mlir::TypeID::get<type>(), kind);
-
-#define MAP_TYPE_TYPE(name, kind, type) \
-    type_type_to_kind.try_emplace(mlir::TypeID::get<type>(), kind);
-
-  MX_IR_FOR_EACH_MLIR_OP(MAP_OP_NAME, MAP_OP_NAME, MAP_OP_NAME, MAP_OP_NAME,
-                         MAP_OP_NAME, MAP_OP_NAME, MAP_OP_NAME, MAP_OP_NAME,
-                         MAP_OP_NAME)
-
-  MX_IR_FOR_EACH_MLIR_OP(MAP_OP_TYPE, MAP_OP_TYPE, MAP_OP_TYPE, MAP_OP_TYPE,
-                         MAP_OP_TYPE, MAP_OP_TYPE, MAP_OP_TYPE, MAP_OP_TYPE,
-                         MAP_OP_TYPE)
-
-  MX_IR_FOR_EACH_MLIR_ATTRIBUTE(MAP_ATTR_TYPE, MAP_ATTR_TYPE, MAP_ATTR_TYPE,
-                                MAP_ATTR_TYPE, MAP_ATTR_TYPE, MAP_ATTR_TYPE,
-                                MAP_ATTR_TYPE, MAP_ATTR_TYPE, MAP_ATTR_TYPE)
-
-  MX_IR_FOR_EACH_MLIR_TYPE(MAP_TYPE_TYPE, MAP_TYPE_TYPE, MAP_TYPE_TYPE,
-                           MAP_TYPE_TYPE, MAP_TYPE_TYPE, MAP_TYPE_TYPE,
-                           MAP_TYPE_TYPE, MAP_TYPE_TYPE, MAP_TYPE_TYPE)
-
-#undef MAP_OP_NAME
-#undef MAP_OP_TYPE
-#undef MAP_ATTR_TYPE
-#undef MAP_TYPE_TYPE
-}
-
-MLIRInitializer::~MLIRInitializer(void) {
-  context.disableMultithreading();
-}
-
-static const MLIRInitializer kMLIR(0);
-
-}  // namespace
-
-OperationKind Operation::classify(::mlir::Operation *opaque) {
-  if (!opaque) {
-    assert(false);
-    return OperationKind::UNKNOWN;
-  }
-
-  mlir::TypeID tid = opaque->getName().getTypeID();
-  if (auto it = kMLIR.op_type_to_kind.find(tid);
-      it != kMLIR.op_type_to_kind.end()) {
-    return it->second;
-  } else {
-    return OperationKind::UNKNOWN;
-  }
-}
-
-OperationKind Operation::classify(std::string_view name_) {
-  llvm::StringRef name(name_);
-  if (auto it = kMLIR.op_name_to_kind.find(name);
-      it != kMLIR.op_name_to_kind.end()) {
-    return it->second;
-  } else {
-    return OperationKind::UNKNOWN;
-  }
-}
-
-AttributeKind Attribute::classify(::mlir::AttributeStorage *opaque) {
-  if (!opaque) {
-    assert(false);
-    return AttributeKind::UNKNOWN;
-  }
-
-  mlir::TypeID tid = opaque->getAbstractAttribute().getTypeID();
-  if (auto it = kMLIR.attr_type_to_kind.find(tid);
-      it != kMLIR.attr_type_to_kind.end()) {
-    return it->second;
-  } else {
-    return AttributeKind::UNKNOWN;
-  }
-}
-
-TypeKind Type::classify(::mlir::TypeStorage *opaque) {
-  if (!opaque) {
-    assert(false);
-    return TypeKind::UNKNOWN;
-  }
-
-  mlir::TypeID tid = opaque->getAbstractType().getTypeID();
-  if (auto it = kMLIR.type_type_to_kind.find(tid);
-      it != kMLIR.type_type_to_kind.end()) {
-    return it->second;
-  } else {
-    return TypeKind::UNKNOWN;
-  }
-}
-
-SourceIRImpl::SourceIRImpl(PackedCompilationId compilation_id_,
-                           EntityProviderPtr ep_, std::string_view mlir)
-    : compilation_id(compilation_id_),
-      ep(std::move(ep_)) {
-
-  llvm::SourceMgr sm;
-  sm.AddNewSourceBuffer(llvm::MemoryBuffer::getMemBuffer(mlir), llvm::SMLoc());
-
-  mlir::MLIRContext &context = ir::kMLIR.Context();
-  context.enterMultiThreadedExecution();
-
-  // NOTE(pag): This should check if it is bytecode internally.
-  mod = mlir::parseSourceFile<mlir::ModuleOp>(sm, &context);
-  if (!mod) {
-    context.exitMultiThreadedExecution();
-    return;
-  }
-
-  // Index the entities / operations in the module.
-  auto result = mod->walk<mlir::WalkOrder::PreOrder>(
-      [this, &context] (mlir::Operation *child) {
-        auto op_kind = Operation::classify(child);
-        
-        if (op_kind == OperationKind::UNKNOWN) {
-          
-          // Even if we have an entity ID for it, overwrite it with an unknown
-          // entity ID, so that we have the invariant that after parsing the
-          // MLIR, all locations represent `OperationId`s or `InvalidId`s.
-          child->setLoc(mlir::OpaqueLoc::get(
-              reinterpret_cast<void *>(kInvalidEntityId), &context));
-          
-          return mlir::WalkResult::advance();
-        }
-
-        auto &kind_ops = operations[op_kind];
-
-        OperationId op_id(
-            compilation_id.Unpack().compilation_id,
-            op_kind,
-            static_cast<EntityOffset>(kind_ops.size()),
-            0u  /* level */);
-
-        kind_ops.push_back(child);
-
-        // The location after parsing is the associated entity of an AST entity.
-        RawEntityId eid = MetaIdFromLocation(child->getLoc());
-        VariantId vid = EntityId(eid).Unpack();
-
-        // Replace the location with our invented (but stable) entity ID for
-        // this operation.
-        auto op_eid = EntityId(op_id).Pack();
-        child->setLoc(mlir::OpaqueLoc::get(
-            reinterpret_cast<void *>(op_eid), &context));
-
-        if (std::holds_alternative<InvalidId>(vid)) {
-          return mlir::WalkResult::advance();
-        }
-
-        if (std::holds_alternative<DeclId>(vid)) {
-          declarations[std::get<DeclId>(vid).kind].emplace_back(eid, child);
-
-        } else if (std::holds_alternative<StmtId>(vid)) {
-          statements[std::get<StmtId>(vid).kind].emplace_back(eid, child);
-        }
-
-        entities[eid].emplace_back(op_kind, child);
-
-        return mlir::WalkResult::advance();
-      });
-
-  context.exitMultiThreadedExecution();
-  assert(result != mlir::WalkResult::interrupt());
-  (void) result;
-}
-
-SourceIRImpl::~SourceIRImpl(void) {}
-
-mlir::Operation *SourceIRImpl::scope(void) const {
-  if (mod) {
-    return reinterpret_cast<mlir::Operation *>(
-        const_cast<void *>(mod.get().getAsOpaquePointer()));
-  } else {
-    return nullptr;
-  }
-}
-
-std::optional<Operation> SourceIRImpl::OperationFor(
-    const std::shared_ptr<const SourceIRImpl> &self,
-    RawEntityId eid) const noexcept {
-
-  auto op_id = EntityId(eid).Extract<OperationId>();
-  if (!op_id) {
-    return std::nullopt;
-  }
-
-  // TODO(pag): Eventually add tower support.
-  if (op_id->level != 0u) {
-    assert(false);
-    return std::nullopt;
-  }
-
-  if (CompilationId(op_id->compilation_id) != compilation_id.Unpack()) {
-    assert(false);
-    return std::nullopt;
-  }
-
-  auto kind_ops_it = operations.find(op_id->kind);
-  if (kind_ops_it == operations.end()) {
-    assert(false);
-    return std::nullopt;
-  }
-
-  auto &kind_ops = kind_ops_it->second;
-  if (kind_ops.size() <= op_id->offset) {
-    assert(false);
-    return std::nullopt;
-  }
-
-  return Operation(self, kind_ops[op_id->offset], op_id->kind);
-}
-
-}  // namespace ir
-
-Index Index::containing(const ir::Operation &entity) {
-  return Index(entity.module_->ep);
-}
-
-std::optional<Decl> Decl::from(const ir::Operation &op) {
-  RawEntityId eid = ir::MetaIdFromLocation(op.op_->getLoc());
-  VariantId vid = EntityId(eid).Unpack();
-  if (!std::holds_alternative<DeclId>(vid)) {
-    return std::nullopt;
-  }
-
-  const auto &ep = op.module_->ep;
-  auto eptr = ep->DeclFor(ep, eid);
-  if (!eptr) {
-    return std::nullopt;
-  }
-
-  return Decl(std::move(eptr));
-}
-
-gap::generator<std::pair<Decl, ir::Operation>>
-Decl::in(const Compilation &tu) {
-  auto source_ir = tu.impl->SourceIRPtr(tu.id());
-  if (!source_ir) {
-    co_return;
-  }
-
-  const auto &ep = source_ir->ep;
-  for (auto &[kind, eid_ops_pairs] : source_ir->declarations) {
-    for (auto [eid, op_ptr] : eid_ops_pairs) {
-      if (auto eptr = ep->DeclFor(ep, eid)) {
-        ir::Operation op(source_ir, op_ptr);
-        co_yield std::pair<Decl, ir::Operation>(
-            Decl(std::move(eptr)),
-            std::move(reinterpret_cast<ir::Operation &>(op)));
-      }
-    }
-  }
-}
-
-gap::generator<std::pair<Decl, ir::Operation>> Decl::in(
-  const Compilation &tu, std::span<const DeclKind> kinds) {
-  if (kinds.empty()) {
-    co_return;
-  }
-
-  auto source_ir = tu.impl->SourceIRPtr(tu.id());
-  if (!source_ir) {
-    co_return;
-  }
-
-  const auto &ep = source_ir->ep;
-  const auto it_end = source_ir->declarations.end();
-  for (auto kind : kinds) {
-    auto it = source_ir->declarations.find(kind);
-    if (it == it_end) {
-      continue;
-    }
-
-    for (auto [eid, op_ptr] : it->second) {
-      if (auto eptr = ep->DeclFor(ep, eid)) {
-        ir::Operation op(source_ir, op_ptr);
-        co_yield std::pair<Decl, ir::Operation>(
-            Decl(std::move(eptr)),
-            std::move(reinterpret_cast<ir::Operation &>(op)));
-      }
-    }
-  }
-}
-
-std::optional<Stmt> Stmt::from(const ir::Operation &op) {
-  RawEntityId eid = ir::MetaIdFromLocation(op.op_->getLoc());
-  VariantId vid = EntityId(eid).Unpack();
-  if (!std::holds_alternative<StmtId>(vid)) {
-    return std::nullopt;
-  }
-
-  const auto &ep = op.module_->ep;
-  auto eptr = ep->StmtFor(ep, eid);
-  if (!eptr) {
-    return std::nullopt;
-  }
-
-  return Stmt(std::move(eptr));
-}
-
-gap::generator<std::pair<Stmt, ir::Operation>>
-Stmt::in(const Compilation &tu) {
-  auto source_ir = tu.impl->SourceIRPtr(tu.id());
-  if (!source_ir) {
-    co_return;
-  }
-
-  const auto &ep = source_ir->ep;
-  for (auto &[kind, eid_ops_pairs] : source_ir->statements) {
-    for (auto [eid, op_ptr] : eid_ops_pairs) {
-      if (auto eptr = ep->StmtFor(ep, eid)) {
-        ir::Operation op(source_ir, op_ptr);
-        co_yield std::pair<Stmt, ir::Operation>(
-            Stmt(std::move(eptr)),
-            std::move(reinterpret_cast<ir::Operation &>(op)));
-      }
-    }
-  }
-}
-
-gap::generator<std::pair<Stmt, ir::Operation>> Stmt::in(
-  const Compilation &tu, std::span<const StmtKind> kinds) {
-    if (kinds.empty()) {
-    co_return;
-  }
-
-  auto source_ir = tu.impl->SourceIRPtr(tu.id());
-  if (!source_ir) {
-    co_return;
-  }
-
-  const auto &ep = source_ir->ep;
-  const auto it_end = source_ir->statements.end();
-  for (auto kind : kinds) {
-    auto it = source_ir->statements.find(kind);
-    if (it == it_end) {
-      continue;
-    }
-
-    for (auto [eid, op_ptr] : it->second) {
-      if (auto eptr = ep->StmtFor(ep, eid)) {
-        ir::Operation op(source_ir, op_ptr);
-        co_yield std::pair<Stmt, ir::Operation>(
-            Stmt(std::move(eptr)),
-            std::move(reinterpret_cast<ir::Operation &>(op)));
-      }
-    }
-  }
-}
-
-namespace ir {
-namespace {
-
-static std::optional<Operation> FirstFrom(
-    std::shared_ptr<const SourceIRImpl> source_ir, RawEntityId eid) {
-
-  if (!source_ir) {
-    return std::nullopt;
-  }
-
-  auto it = source_ir->entities.find(eid);
-  if (it == source_ir->entities.end()) {
-    return std::nullopt;
-  }
-
-  for (auto [op_kind, op_ptr] : it->second) {
-    ::mx::ir::Operation op(std::move(source_ir), op_ptr, op_kind);
-    return reinterpret_cast<Operation &&>(op);
-  }
-
-  return std::nullopt;
-}
-
-static std::optional<Operation> FirstFromOfKind(
-    std::shared_ptr<const SourceIRImpl> source_ir, RawEntityId eid,
-    OperationKind kind) {
-
-  if (!source_ir) {
-    return std::nullopt;
-  }
-
-  auto it = source_ir->entities.find(eid);
-  if (it == source_ir->entities.end()) {
-    return std::nullopt;
-  }
-
-  for (auto [op_kind, op_ptr] : it->second) {
-    if (op_kind != kind) {
-      continue;
-    }
-
-    ::mx::ir::Operation op(std::move(source_ir), op_ptr, op_kind);
-    return reinterpret_cast<Operation &&>(op);
-  }
-
-  return std::nullopt;
-}
-
-static gap::generator<Operation> AllFrom(
-    std::shared_ptr<const SourceIRImpl> source_ir, RawEntityId eid) {
-
-  if (!source_ir) {
-    co_return;
-  }
-
-  auto it = source_ir->entities.find(eid);
-  if (it == source_ir->entities.end()) {
-    co_return;
-  }
-
-  for (auto [op_kind, op_ptr] : it->second) {
-    co_yield ::mx::ir::Operation(source_ir, op_ptr, op_kind);
-  }
-}
-
-}  // namespace
-
-std::optional<Operation> Operation::first_from(const ::mx::Decl &that) {
-  auto compilation = Compilation::containing(that);
-  return FirstFrom(
-      compilation.impl->SourceIRPtr(compilation.id()),
-      that.id().Pack());
-}
-
-std::optional<Operation> Operation::first_from(const ::mx::Decl &that,
-                                               OperationKind op_kind) {
-  auto compilation = Compilation::containing(that);
-  return FirstFromOfKind(
-      compilation.impl->SourceIRPtr(compilation.id()),
-      that.id().Pack(),
-      op_kind);
-}
-
-gap::generator<Operation> Operation::all_from(const ::mx::Decl &that) {
-  auto compilation = Compilation::containing(that);
-  return AllFrom(
-      compilation.impl->SourceIRPtr(compilation.id()),
-      that.id().Pack());
-}
-
-std::optional<Operation> Operation::first_from(const ::mx::Stmt &that) {
-  auto compilation = Compilation::containing(that);
-  return FirstFrom(
-      compilation.impl->SourceIRPtr(compilation.id()),
-      that.id().Pack());
-}
-
-std::optional<Operation> Operation::first_from(const ::mx::Stmt &that,
-                                               OperationKind op_kind) {
-  auto compilation = Compilation::containing(that);
-  return FirstFromOfKind(
-      compilation.impl->SourceIRPtr(compilation.id()),
-      that.id().Pack(),
-      op_kind);
-}
-
-gap::generator<Operation> Operation::all_from(const ::mx::Stmt &that) {
-  auto compilation = Compilation::containing(that);
-  return AllFrom(
-      compilation.impl->SourceIRPtr(compilation.id()),
-      that.id().Pack());
-}
-
-// Return a reference to the global MLIR context.
-mlir::MLIRContext &GlobalMLIRContext(void) {
-  return kMLIR.Context();
-}
-
-}  // namespace ir
-}  // namespace mx
diff --git a/lib/IR/SourceIR.h b/lib/IR/SourceIR.h
deleted file mode 100644
index 9628b4183..000000000
--- a/lib/IR/SourceIR.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include <unordered_map>
-#include <vector>
-
-#include <mlir/IR/BuiltinOps.h>
-#include <mlir/IR/DialectRegistry.h>
-#include <mlir/IR/MLIRContext.h>
-#include <mlir/IR/OwningOpRef.h>
-
-#include "../Types.h"
-#include "../EntityProvider.h"
-
-namespace llvm {
-class SourceMgr;
-} // namespace llvm
-namespace mx {
-
-enum class DeclKind : unsigned char;
-enum class StmtKind : unsigned char;
-enum class TypeKind : unsigned char;
-
-class Decl;
-class Fragment;
-class FragmentImpl;
-class Stmt;
-
-namespace ir {
-
-enum class AttributeKind : unsigned;
-enum class OperationKind : unsigned;
-enum class TypeKind : unsigned;
-
-class SourceIRImpl {
- public:
-  friend class ::mx::Decl;
-  friend class ::mx::Fragment;
-  friend class ::mx::FragmentImpl;
-  friend class ::mx::Stmt;
-
-  const PackedCompilationId compilation_id;
-  const EntityProviderPtr ep;
-
-  mlir::OwningOpRef<mlir::ModuleOp> mod;
-
-  using IdOpPair = std::pair<mx::RawEntityId, mlir::Operation *>;
-  using IdOpPairList = std::vector<IdOpPair>;
-
-  template <typename T>
-  using IdOpPairListMap = std::unordered_map<T, IdOpPairList>;
-
-  // All operations.
-  std::unordered_map<ir::OperationKind, std::vector<mlir::Operation *>>
-      operations;
-
-  // Operations that belong to the high-level dialect, and have a corresponding
-  // entity ID.
-  IdOpPairListMap<::mx::DeclKind> declarations;
-  IdOpPairListMap<::mx::StmtKind> statements;
-
-  // High-level operations that have an entity id.
-  std::unordered_map<
-      mx::RawEntityId,
-      std::vector<std::pair<OperationKind, mlir::Operation *>>>
-      entities;
-
-  virtual ~SourceIRImpl(void);
-
-  explicit SourceIRImpl(PackedCompilationId compilation_id_, EntityProviderPtr ep_,
-                        std::string_view mlir);
-
-  mlir::Operation *scope(void) const;
-
-  std::optional<Operation> OperationFor(
-      const std::shared_ptr<const SourceIRImpl> &self,
-      RawEntityId eid) const noexcept;
-};
-
-bool OperationIdsMatch(mlir::Operation *a, mlir::Operation *b);
-
-bool BlocksMatch(
-    const std::shared_ptr<const SourceIRImpl> &a_mod, mlir::Block *a,
-    const std::shared_ptr<const SourceIRImpl> &b_mod, mlir::Block *b);
-
-// Return a reference to the global MLIR context.
-mlir::MLIRContext &GlobalMLIRContext(void);
-
-}  // namespace ir
-}  // namespace mx
diff --git a/lib/IR/Type.h b/lib/IR/Type.h
deleted file mode 100644
index 0878ca2b4..000000000
--- a/lib/IR/Type.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#define MX_IR_FOR_EACH_MLIR_TYPE(_builtin, _llvm, _memref, _abi, _ll, _hl, _core, _meta, _unsup) \
-   _builtin(ShapedType, TypeKind::BUILTIN_SHAPED, mlir::ShapedType) \
-   _builtin(FloatType, TypeKind::BUILTIN_FLOAT, mlir::FloatType) \
-   _builtin(ComplexType, TypeKind::BUILTIN_COMPLEX, mlir::ComplexType) \
-   _builtin(Float8E5M2Type, TypeKind::BUILTIN_FLOAT8_E5_M2, mlir::Float8E5M2Type) \
-   _builtin(Float8E4M3FNType, TypeKind::BUILTIN_FLOAT8_E4_M3_FN, mlir::Float8E4M3FNType) \
-   _builtin(Float8E5M2FNUZType, TypeKind::BUILTIN_FLOAT8_E5_M2_FNUZ, mlir::Float8E5M2FNUZType) \
-   _builtin(Float8E4M3FNUZType, TypeKind::BUILTIN_FLOAT8_E4_M3_FNUZ, mlir::Float8E4M3FNUZType) \
-   _builtin(Float8E4M3B11FNUZType, TypeKind::BUILTIN_FLOAT8_E4_M3_B11_FNUZ, mlir::Float8E4M3B11FNUZType) \
-   _builtin(BFloat16Type, TypeKind::BUILTIN_B_FLOAT16, mlir::BFloat16Type) \
-   _builtin(Float16Type, TypeKind::BUILTIN_FLOAT16, mlir::Float16Type) \
-   _builtin(FloatTF32Type, TypeKind::BUILTIN_FLOAT_TF32, mlir::FloatTF32Type) \
-   _builtin(Float32Type, TypeKind::BUILTIN_FLOAT32, mlir::Float32Type) \
-   _builtin(Float64Type, TypeKind::BUILTIN_FLOAT64, mlir::Float64Type) \
-   _builtin(Float80Type, TypeKind::BUILTIN_FLOAT80, mlir::Float80Type) \
-   _builtin(Float128Type, TypeKind::BUILTIN_FLOAT128, mlir::Float128Type) \
-   _builtin(FunctionType, TypeKind::BUILTIN_FUNCTION, mlir::FunctionType) \
-   _builtin(IndexType, TypeKind::BUILTIN_INDEX, mlir::IndexType) \
-   _builtin(IntegerType, TypeKind::BUILTIN_INTEGER, mlir::IntegerType) \
-   _builtin(MemRefType, TypeKind::BUILTIN_MEM_REF, mlir::MemRefType) \
-   _builtin(NoneType, TypeKind::BUILTIN_NONE, mlir::NoneType) \
-   _builtin(OpaqueType, TypeKind::BUILTIN_OPAQUE, mlir::OpaqueType) \
-   _builtin(RankedTensorType, TypeKind::BUILTIN_RANKED_TENSOR, mlir::RankedTensorType) \
-   _builtin(TupleType, TypeKind::BUILTIN_TUPLE, mlir::TupleType) \
-   _builtin(UnrankedMemRefType, TypeKind::BUILTIN_UNRANKED_MEM_REF, mlir::UnrankedMemRefType) \
-   _builtin(UnrankedTensorType, TypeKind::BUILTIN_UNRANKED_TENSOR, mlir::UnrankedTensorType) \
-   _builtin(VectorType, TypeKind::BUILTIN_VECTOR, mlir::VectorType) \
-   _llvm(LLVMArrayType, TypeKind::LLVM_ARRAY, mlir::LLVM::LLVMArrayType) \
-   _llvm(LLVMFunctionType, TypeKind::LLVM_FUNCTION, mlir::LLVM::LLVMFunctionType) \
-   _llvm(LLVMPointerType, TypeKind::LLVM_POINTER, mlir::LLVM::LLVMPointerType) \
-   _llvm(LLVMFixedVectorType, TypeKind::LLVM_FIXED_VECTOR, mlir::LLVM::LLVMFixedVectorType) \
-   _llvm(LLVMScalableVectorType, TypeKind::LLVM_SCALABLE_VECTOR, mlir::LLVM::LLVMScalableVectorType) \
-   _llvm(LLVMTargetExtType, TypeKind::LLVM_TARGET_EXT, mlir::LLVM::LLVMTargetExtType) \
-   _hl(RecordType, TypeKind::HL_RECORD, vast::hl::RecordType) \
-   _hl(EnumType, TypeKind::HL_ENUM, vast::hl::EnumType) \
-   _hl(TypedefType, TypeKind::HL_TYPEDEF, vast::hl::TypedefType) \
-   _hl(ElaboratedType, TypeKind::HL_ELABORATED, vast::hl::ElaboratedType) \
-   _hl(LabelType, TypeKind::HL_LABEL, vast::hl::LabelType) \
-   _hl(ParenType, TypeKind::HL_PAREN, vast::hl::ParenType) \
-   _hl(LValueType, TypeKind::HL_L_VALUE, vast::hl::LValueType) \
-   _hl(RValueType, TypeKind::HL_R_VALUE, vast::hl::RValueType) \
-   _hl(VoidType, TypeKind::HL_VOID, vast::hl::VoidType) \
-   _hl(BoolType, TypeKind::HL_BOOL, vast::hl::BoolType) \
-   _hl(CharType, TypeKind::HL_CHAR, vast::hl::CharType) \
-   _hl(ShortType, TypeKind::HL_SHORT, vast::hl::ShortType) \
-   _hl(IntType, TypeKind::HL_INT, vast::hl::IntType) \
-   _hl(LongType, TypeKind::HL_LONG, vast::hl::LongType) \
-   _hl(LongLongType, TypeKind::HL_LONG_LONG, vast::hl::LongLongType) \
-   _hl(Int128Type, TypeKind::HL_INT128, vast::hl::Int128Type) \
-   _hl(HalfType, TypeKind::HL_HALF, vast::hl::HalfType) \
-   _hl(BFloat16Type, TypeKind::HL_B_FLOAT16, vast::hl::BFloat16Type) \
-   _hl(FloatType, TypeKind::HL_FLOAT, vast::hl::FloatType) \
-   _hl(DoubleType, TypeKind::HL_DOUBLE, vast::hl::DoubleType) \
-   _hl(LongDoubleType, TypeKind::HL_LONG_DOUBLE, vast::hl::LongDoubleType) \
-   _hl(Float128Type, TypeKind::HL_FLOAT128, vast::hl::Float128Type) \
-   _hl(ComplexType, TypeKind::HL_COMPLEX, vast::hl::ComplexType) \
-   _hl(PointerType, TypeKind::HL_POINTER, vast::hl::PointerType) \
-   _hl(ArrayType, TypeKind::HL_ARRAY, vast::hl::ArrayType) \
-   _hl(VectorType, TypeKind::HL_VECTOR, vast::hl::VectorType) \
-   _hl(DecayedType, TypeKind::HL_DECAYED, vast::hl::DecayedType) \
-   _hl(AttributedType, TypeKind::HL_ATTRIBUTED, vast::hl::AttributedType) \
-   _hl(AdjustedType, TypeKind::HL_ADJUSTED, vast::hl::AdjustedType) \
-   _hl(ReferenceType, TypeKind::HL_REFERENCE, vast::hl::ReferenceType) \
-   _hl(TypeOfExprType, TypeKind::HL_TYPE_OF_EXPR, vast::hl::TypeOfExprType) \
-   _hl(TypeOfTypeType, TypeKind::HL_TYPE_OF_TYPE, vast::hl::TypeOfTypeType) \
-   _hl(AutoType, TypeKind::HL_AUTO, vast::hl::AutoType) \
-   _hl(AtomicType, TypeKind::HL_ATOMIC, vast::hl::AtomicType) \
-   _core(FunctionType, TypeKind::CORE_FUNCTION, vast::core::FunctionType) \
-   _unsup(UnsupportedType, TypeKind::UNSUP_UNSUPPORTED, vast::unsup::UnsupportedType)
-
-#define MX_IR_NUM_MLIR_TYPES 68
-
diff --git a/lib/IR/TypeKind.cpp b/lib/IR/TypeKind.cpp
deleted file mode 100644
index c8cf949c5..000000000
--- a/lib/IR/TypeKind.cpp
+++ /dev/null
@@ -1,222 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/TypeKind.h>
-
-namespace mx {
-
-const char *EnumeratorName(ir::TypeKind kind) {
-  switch (kind) {
-    default: return "UNKNOWN";
-    case ir::TypeKind::BUILTIN_SHAPED: return "BUILTIN_SHAPED";
-    case ir::TypeKind::BUILTIN_FLOAT: return "BUILTIN_FLOAT";
-    case ir::TypeKind::BUILTIN_COMPLEX: return "BUILTIN_COMPLEX";
-    case ir::TypeKind::BUILTIN_FLOAT8_E5_M2: return "BUILTIN_FLOAT8_E5_M2";
-    case ir::TypeKind::BUILTIN_FLOAT8_E4_M3_FN: return "BUILTIN_FLOAT8_E4_M3_FN";
-    case ir::TypeKind::BUILTIN_FLOAT8_E5_M2_FNUZ: return "BUILTIN_FLOAT8_E5_M2_FNUZ";
-    case ir::TypeKind::BUILTIN_FLOAT8_E4_M3_FNUZ: return "BUILTIN_FLOAT8_E4_M3_FNUZ";
-    case ir::TypeKind::BUILTIN_FLOAT8_E4_M3_B11_FNUZ: return "BUILTIN_FLOAT8_E4_M3_B11_FNUZ";
-    case ir::TypeKind::BUILTIN_B_FLOAT16: return "BUILTIN_B_FLOAT16";
-    case ir::TypeKind::BUILTIN_FLOAT16: return "BUILTIN_FLOAT16";
-    case ir::TypeKind::BUILTIN_FLOAT_TF32: return "BUILTIN_FLOAT_TF32";
-    case ir::TypeKind::BUILTIN_FLOAT32: return "BUILTIN_FLOAT32";
-    case ir::TypeKind::BUILTIN_FLOAT64: return "BUILTIN_FLOAT64";
-    case ir::TypeKind::BUILTIN_FLOAT80: return "BUILTIN_FLOAT80";
-    case ir::TypeKind::BUILTIN_FLOAT128: return "BUILTIN_FLOAT128";
-    case ir::TypeKind::BUILTIN_FUNCTION: return "BUILTIN_FUNCTION";
-    case ir::TypeKind::BUILTIN_INDEX: return "BUILTIN_INDEX";
-    case ir::TypeKind::BUILTIN_INTEGER: return "BUILTIN_INTEGER";
-    case ir::TypeKind::BUILTIN_MEM_REF: return "BUILTIN_MEM_REF";
-    case ir::TypeKind::BUILTIN_NONE: return "BUILTIN_NONE";
-    case ir::TypeKind::BUILTIN_OPAQUE: return "BUILTIN_OPAQUE";
-    case ir::TypeKind::BUILTIN_RANKED_TENSOR: return "BUILTIN_RANKED_TENSOR";
-    case ir::TypeKind::BUILTIN_TUPLE: return "BUILTIN_TUPLE";
-    case ir::TypeKind::BUILTIN_UNRANKED_MEM_REF: return "BUILTIN_UNRANKED_MEM_REF";
-    case ir::TypeKind::BUILTIN_UNRANKED_TENSOR: return "BUILTIN_UNRANKED_TENSOR";
-    case ir::TypeKind::BUILTIN_VECTOR: return "BUILTIN_VECTOR";
-    case ir::TypeKind::LLVM_ARRAY: return "LLVM_ARRAY";
-    case ir::TypeKind::LLVM_FUNCTION: return "LLVM_FUNCTION";
-    case ir::TypeKind::LLVM_POINTER: return "LLVM_POINTER";
-    case ir::TypeKind::LLVM_FIXED_VECTOR: return "LLVM_FIXED_VECTOR";
-    case ir::TypeKind::LLVM_SCALABLE_VECTOR: return "LLVM_SCALABLE_VECTOR";
-    case ir::TypeKind::LLVM_TARGET_EXT: return "LLVM_TARGET_EXT";
-    case ir::TypeKind::HL_RECORD: return "HL_RECORD";
-    case ir::TypeKind::HL_ENUM: return "HL_ENUM";
-    case ir::TypeKind::HL_TYPEDEF: return "HL_TYPEDEF";
-    case ir::TypeKind::HL_ELABORATED: return "HL_ELABORATED";
-    case ir::TypeKind::HL_LABEL: return "HL_LABEL";
-    case ir::TypeKind::HL_PAREN: return "HL_PAREN";
-    case ir::TypeKind::HL_L_VALUE: return "HL_L_VALUE";
-    case ir::TypeKind::HL_R_VALUE: return "HL_R_VALUE";
-    case ir::TypeKind::HL_VOID: return "HL_VOID";
-    case ir::TypeKind::HL_BOOL: return "HL_BOOL";
-    case ir::TypeKind::HL_CHAR: return "HL_CHAR";
-    case ir::TypeKind::HL_SHORT: return "HL_SHORT";
-    case ir::TypeKind::HL_INT: return "HL_INT";
-    case ir::TypeKind::HL_LONG: return "HL_LONG";
-    case ir::TypeKind::HL_LONG_LONG: return "HL_LONG_LONG";
-    case ir::TypeKind::HL_INT128: return "HL_INT128";
-    case ir::TypeKind::HL_HALF: return "HL_HALF";
-    case ir::TypeKind::HL_B_FLOAT16: return "HL_B_FLOAT16";
-    case ir::TypeKind::HL_FLOAT: return "HL_FLOAT";
-    case ir::TypeKind::HL_DOUBLE: return "HL_DOUBLE";
-    case ir::TypeKind::HL_LONG_DOUBLE: return "HL_LONG_DOUBLE";
-    case ir::TypeKind::HL_FLOAT128: return "HL_FLOAT128";
-    case ir::TypeKind::HL_COMPLEX: return "HL_COMPLEX";
-    case ir::TypeKind::HL_POINTER: return "HL_POINTER";
-    case ir::TypeKind::HL_ARRAY: return "HL_ARRAY";
-    case ir::TypeKind::HL_VECTOR: return "HL_VECTOR";
-    case ir::TypeKind::HL_DECAYED: return "HL_DECAYED";
-    case ir::TypeKind::HL_ATTRIBUTED: return "HL_ATTRIBUTED";
-    case ir::TypeKind::HL_ADJUSTED: return "HL_ADJUSTED";
-    case ir::TypeKind::HL_REFERENCE: return "HL_REFERENCE";
-    case ir::TypeKind::HL_TYPE_OF_EXPR: return "HL_TYPE_OF_EXPR";
-    case ir::TypeKind::HL_TYPE_OF_TYPE: return "HL_TYPE_OF_TYPE";
-    case ir::TypeKind::HL_AUTO: return "HL_AUTO";
-    case ir::TypeKind::HL_ATOMIC: return "HL_ATOMIC";
-    case ir::TypeKind::CORE_FUNCTION: return "CORE_FUNCTION";
-    case ir::TypeKind::UNSUP_UNSUPPORTED: return "UNSUP_UNSUPPORTED";
-  }
-}
-
-bool IsBuiltinTypeKind(ir::TypeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::TypeKind::BUILTIN_SHAPED:
-    case mx::ir::TypeKind::BUILTIN_FLOAT:
-    case mx::ir::TypeKind::BUILTIN_COMPLEX:
-    case mx::ir::TypeKind::BUILTIN_FLOAT8_E5_M2:
-    case mx::ir::TypeKind::BUILTIN_FLOAT8_E4_M3_FN:
-    case mx::ir::TypeKind::BUILTIN_FLOAT8_E5_M2_FNUZ:
-    case mx::ir::TypeKind::BUILTIN_FLOAT8_E4_M3_FNUZ:
-    case mx::ir::TypeKind::BUILTIN_FLOAT8_E4_M3_B11_FNUZ:
-    case mx::ir::TypeKind::BUILTIN_B_FLOAT16:
-    case mx::ir::TypeKind::BUILTIN_FLOAT16:
-    case mx::ir::TypeKind::BUILTIN_FLOAT_TF32:
-    case mx::ir::TypeKind::BUILTIN_FLOAT32:
-    case mx::ir::TypeKind::BUILTIN_FLOAT64:
-    case mx::ir::TypeKind::BUILTIN_FLOAT80:
-    case mx::ir::TypeKind::BUILTIN_FLOAT128:
-    case mx::ir::TypeKind::BUILTIN_FUNCTION:
-    case mx::ir::TypeKind::BUILTIN_INDEX:
-    case mx::ir::TypeKind::BUILTIN_INTEGER:
-    case mx::ir::TypeKind::BUILTIN_MEM_REF:
-    case mx::ir::TypeKind::BUILTIN_NONE:
-    case mx::ir::TypeKind::BUILTIN_OPAQUE:
-    case mx::ir::TypeKind::BUILTIN_RANKED_TENSOR:
-    case mx::ir::TypeKind::BUILTIN_TUPLE:
-    case mx::ir::TypeKind::BUILTIN_UNRANKED_MEM_REF:
-    case mx::ir::TypeKind::BUILTIN_UNRANKED_TENSOR:
-    case mx::ir::TypeKind::BUILTIN_VECTOR:
-      return true;
-  }
-}
-
-bool IsLLVMIRTypeKind(ir::TypeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::TypeKind::LLVM_ARRAY:
-    case mx::ir::TypeKind::LLVM_FUNCTION:
-    case mx::ir::TypeKind::LLVM_POINTER:
-    case mx::ir::TypeKind::LLVM_FIXED_VECTOR:
-    case mx::ir::TypeKind::LLVM_SCALABLE_VECTOR:
-    case mx::ir::TypeKind::LLVM_TARGET_EXT:
-      return true;
-  }
-}
-
-bool IsMemRefTypeKind(ir::TypeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-  }
-}
-
-bool IsABITypeKind(ir::TypeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-  }
-}
-
-bool IsLowLevelTypeKind(ir::TypeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-  }
-}
-
-bool IsHighLevelTypeKind(ir::TypeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::TypeKind::HL_RECORD:
-    case mx::ir::TypeKind::HL_ENUM:
-    case mx::ir::TypeKind::HL_TYPEDEF:
-    case mx::ir::TypeKind::HL_ELABORATED:
-    case mx::ir::TypeKind::HL_LABEL:
-    case mx::ir::TypeKind::HL_PAREN:
-    case mx::ir::TypeKind::HL_L_VALUE:
-    case mx::ir::TypeKind::HL_R_VALUE:
-    case mx::ir::TypeKind::HL_VOID:
-    case mx::ir::TypeKind::HL_BOOL:
-    case mx::ir::TypeKind::HL_CHAR:
-    case mx::ir::TypeKind::HL_SHORT:
-    case mx::ir::TypeKind::HL_INT:
-    case mx::ir::TypeKind::HL_LONG:
-    case mx::ir::TypeKind::HL_LONG_LONG:
-    case mx::ir::TypeKind::HL_INT128:
-    case mx::ir::TypeKind::HL_HALF:
-    case mx::ir::TypeKind::HL_B_FLOAT16:
-    case mx::ir::TypeKind::HL_FLOAT:
-    case mx::ir::TypeKind::HL_DOUBLE:
-    case mx::ir::TypeKind::HL_LONG_DOUBLE:
-    case mx::ir::TypeKind::HL_FLOAT128:
-    case mx::ir::TypeKind::HL_COMPLEX:
-    case mx::ir::TypeKind::HL_POINTER:
-    case mx::ir::TypeKind::HL_ARRAY:
-    case mx::ir::TypeKind::HL_VECTOR:
-    case mx::ir::TypeKind::HL_DECAYED:
-    case mx::ir::TypeKind::HL_ATTRIBUTED:
-    case mx::ir::TypeKind::HL_ADJUSTED:
-    case mx::ir::TypeKind::HL_REFERENCE:
-    case mx::ir::TypeKind::HL_TYPE_OF_EXPR:
-    case mx::ir::TypeKind::HL_TYPE_OF_TYPE:
-    case mx::ir::TypeKind::HL_AUTO:
-    case mx::ir::TypeKind::HL_ATOMIC:
-      return true;
-  }
-}
-
-bool IsCoreTypeKind(ir::TypeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::TypeKind::CORE_FUNCTION:
-      return true;
-  }
-}
-
-bool IsMetaTypeKind(ir::TypeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-  }
-}
-
-bool IsUnsupportedTypeKind(ir::TypeKind kind) {
-  switch (kind) {
-    default:
-      return false;
-    case mx::ir::TypeKind::UNSUP_UNSUPPORTED:
-      return true;
-  }
-}
-
-}  // namespace mx
diff --git a/lib/IR/Unsupported/Operation.cpp b/lib/IR/Unsupported/Operation.cpp
deleted file mode 100644
index 9050a4411..000000000
--- a/lib/IR/Unsupported/Operation.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Unsupported/Operation.h>
-
-#include <multiplier/IR/Attribute.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Region.h>
-#include <multiplier/IR/Type.h>
-
-#include <ios>
-#include <string>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <vast/Dialect/Dialects.hpp>
-#include <vast/Dialect/Unsupported/UnsupportedOps.hpp>
-
-namespace mx::ir::unsup {
-std::optional<Operation> Operation::from(const ::mx::ir::Operation &that) {
-  if (IsUnsupportedOperationKind(that.kind())) {
-    return reinterpret_cast<const Operation &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UnsupportedDeclOp> UnsupportedDeclOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::UNSUP_DECL) {
-    return reinterpret_cast<const UnsupportedDeclOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UnsupportedDeclOp> UnsupportedDeclOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::unsup::UnsupportedDecl UnsupportedDeclOp::underlying_repr(void) const noexcept {
-  return ::vast::unsup::UnsupportedDecl(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Region UnsupportedDeclOp::body(void) const {
-  auto &val = underlying_repr().getBody();
-  return ::mx::ir::Region(module_, val);
-}
-
-std::string_view UnsupportedDeclOp::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-std::optional<UnsupportedStmtOp> UnsupportedStmtOp::from(const ::mx::ir::Operation &that) {
-  if (that.kind() == OperationKind::UNSUP_STMT) {
-    return reinterpret_cast<const UnsupportedStmtOp &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UnsupportedStmtOp> UnsupportedStmtOp::producing(const ::mx::ir::Value &that) {
-  if (auto op = ::mx::ir::Operation::producing(that)) {
-    return from(op.value());
-  }
-  return std::nullopt;
-}
-
-::vast::unsup::UnsupportedStmt UnsupportedStmtOp::underlying_repr(void) const noexcept {
-  return ::vast::unsup::UnsupportedStmt(this->::mx::ir::Operation::op_);
-}
-
-::mx::ir::Value UnsupportedStmtOp::result(void) const {
-  auto val = underlying_repr().getResult();
-  return ::mx::ir::Value(module_, val.getAsOpaquePointer());
-}
-
-gap::generator<::mx::ir::Region> UnsupportedStmtOp::children(void) const & {
-  decltype(auto) regions = underlying_repr().getChildren();
-  for (auto &region : regions) {
-    co_yield ::mx::ir::Region(module_, &region);
-  }
-}
-
-std::string_view UnsupportedStmtOp::name(void) const {
-  auto val = underlying_repr().getName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-}  // namespace mx::ir::unsup
diff --git a/lib/IR/Unsupported/Type.cpp b/lib/IR/Unsupported/Type.cpp
deleted file mode 100644
index c0ca68738..000000000
--- a/lib/IR/Unsupported/Type.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-// Auto-generated file; do not modify!
-
-#include <multiplier/IR/Unsupported/Type.h>
-
-#include <multiplier/IR/Attribute.h>
-
-#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
-#include <vast/Dialect/Unsupported/UnsupportedTypes.hpp>
-
-namespace mx::ir::unsup {
-std::optional<Type> Type::from(const ::mx::ir::Type &that) {
-  if (IsUnsupportedTypeKind(that.kind())) {
-    return reinterpret_cast<const Type &>(that);
-  }
-  return std::nullopt;
-}
-
-std::optional<UnsupportedType> UnsupportedType::from(const ::mx::ir::Type &that) {
-  if (that.kind() == TypeKind::UNSUP_UNSUPPORTED) {
-    return reinterpret_cast<const UnsupportedType &>(that);
-  }
-  return std::nullopt;
-}
-
-::vast::unsup::UnsupportedType UnsupportedType::underlying_repr(void) const noexcept {
-  return ::vast::unsup::UnsupportedType(this->::mx::ir::Type::type_);
-}
-
-std::string_view UnsupportedType::origin_name(void) const {
-  auto val = underlying_repr().getOriginName();
-  if (auto size = val.size()) {
-    return std::string_view(val.data(), size);
-  } else {
-    return {};
-  }
-}
-
-}  // namespace mx::ir::unsup
diff --git a/lib/IR/Value.cpp b/lib/IR/Value.cpp
deleted file mode 100644
index 551a47012..000000000
--- a/lib/IR/Value.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) 2023-present, Trail of Bits, Inc.
-//
-// This source code is licensed in accordance with the terms specified in
-// the LICENSE file found in the root directory of this source tree.
-
-#include <multiplier/IR/Value.h>
-
-#include <cassert>
-
-#include <mlir/IR/Block.h>
-#include <mlir/IR/Operation.h>
-#include <mlir/IR/OperationSupport.h>
-#include <mlir/IR/Value.h>
-#include <multiplier/IR/Block.h>
-#include <multiplier/IR/Operation.h>
-#include <multiplier/IR/Type.h>
-
-namespace mx::ir {
-
-MX_EXPORT const char *EnumeratorName(ValueKind kind) {
-  switch (kind) {
-    case ValueKind::OPERATION_RESULT: return "OPERATION_RESULT";
-    case ValueKind::BLOCK_ARGUMENT: return "BLOCK_ARGUMENT";
-    default: return "<invalid>";
-  }
-}
-
-Value::Value(std::shared_ptr<const SourceIRImpl> module, void *value)
-    : module_(std::move(module)),
-      impl_(value) {
-  assert(value != nullptr);
-}
-
-ValueKind Value::kind(void) const noexcept {
-  switch (impl_.value->getKind()) {
-    case mlir::detail::ValueImpl::Kind::InlineOpResult:
-    case mlir::detail::ValueImpl::Kind::OutOfLineOpResult:
-      return ValueKind::OPERATION_RESULT;
-    case mlir::detail::ValueImpl::Kind::BlockArgument:
-      return ValueKind::BLOCK_ARGUMENT;
-  }
-}
-
-Type Value::type(void) const noexcept {
-  mlir::Value val = mlir::Value::getFromOpaquePointer(impl_.opaque);
-  return Type(
-      val.getContext(),
-      reinterpret_cast<const mlir::TypeStorage *>(
-          val.getType().getAsOpaquePointer()));
-}
-
-// Generate the uses of this value.
-gap::generator<Operand> Value::uses(void) const & noexcept {
-  for (mlir::OpOperand &use : mlir::Value(impl_.value).getUses()) {
-    co_yield Operand(module_, &use);
-  }
-}
-
-bool Value::operator==(const Value &that) const noexcept {
-  auto that_kind = that.impl_.value->getKind();
-  if (impl_.value->getKind() != that_kind) {
-    return false;
-  }
-
-  switch (impl_.value->getKind()) {
-    case mlir::detail::ValueImpl::Kind::InlineOpResult:
-    case mlir::detail::ValueImpl::Kind::OutOfLineOpResult:
-      return reinterpret_cast<const Result &>(*this) ==
-             reinterpret_cast<const Result &>(that);
-
-    case mlir::detail::ValueImpl::Kind::BlockArgument:
-      return reinterpret_cast<const Argument &>(*this) ==
-             reinterpret_cast<const Argument &>(that);
-  }
-}
-
-}  // namespace mx::ir
diff --git a/lib/Index.cpp b/lib/Index.cpp
index 18742cb67..372c084ca 100644
--- a/lib/Index.cpp
+++ b/lib/Index.cpp
@@ -5,6 +5,7 @@
 
 #include <multiplier/Index.h>
 
+#include <algorithm>
 #include <cassert>
 #include <multiplier/AST/Attr.h>
 #include <multiplier/AST/Designator.h>
@@ -15,7 +16,6 @@
 #include "Decl.h"
 #include "File.h"
 #include "Fragment.h"
-#include "IR/SourceIR.h"
 #include "Macro.h"
 #include "Pseudo.h"
 #include "Stmt.h"
@@ -182,29 +182,6 @@ gap::generator<File> Index::files(void) const & {
   }
 }
 
-std::optional<ir::Operation> Index::operation(RawEntityId id) const {
-  auto op_id = EntityId(id).Extract<OperationId>();
-  if (!op_id) {
-    return std::nullopt;
-  }
-
-  CompilationId compilation_id(op_id->compilation_id);
-  auto cptr = impl->CompilationFor(impl, EntityId(compilation_id).Pack());
-  if (!cptr) {
-    assert(false);
-    return std::nullopt;
-  }
-
-  if (auto source_ir = cptr->SourceIRPtr(compilation_id)) {
-    if (auto op = source_ir->OperationFor(source_ir, id)) {
-      return op;
-    }
-  }
-
-  assert(false);
-  return std::nullopt;
-}
-
 #define MX_DEFINE_GETTER(ns_path, type_name, lower_name, enum_name, category) \
   std::optional<ns_path type_name> Index::lower_name(RawEntityId id) const { \
     if (CategoryFromEntityId(id) == EntityCategory::enum_name) { \
@@ -218,7 +195,7 @@ std::optional<ir::Operation> Index::operation(RawEntityId id) const {
 MX_FOR_EACH_ENTITY_CATEGORY(MX_DEFINE_GETTER, MX_IGNORE_ENTITY_CATEGORY,
                             MX_DEFINE_GETTER, MX_DEFINE_GETTER,
                             MX_DEFINE_GETTER, MX_DEFINE_GETTER,
-                            MX_DEFINE_GETTER, MX_IGNORE_ENTITY_CATEGORY)
+                            MX_DEFINE_GETTER)
 #undef MX_DEFINE_GETTER
 
 // Download a fragment based off of an entity ID.
@@ -285,13 +262,6 @@ VariantEntity Index::entity(EntityId eid) const {
     }
     assert(false);
 
-  // It's an IR operation.
-  } else if (std::holds_alternative<OperationId>(vid)) {
-    if (auto op = operation(eid.Pack())) {
-      return op.value();
-    }
-    assert(false);
-
 #define MX_DISPATCH_GETTER(ns_path, type_name, lower_name, enum_name, category) \
     } else if (std::holds_alternative<type_name ## Id>(vid)) { \
       if (type_name ## ImplPtr eptr = impl->type_name ## For(impl, raw_id)) { \
@@ -305,7 +275,7 @@ VariantEntity Index::entity(EntityId eid) const {
     MX_FOR_EACH_ENTITY_CATEGORY(MX_DISPATCH_GETTER, MX_IGNORE_ENTITY_CATEGORY,
                                 MX_DISPATCH_GETTER, MX_DISPATCH_GETTER,
                                 MX_DISPATCH_GETTER, MX_DISPATCH_GETTER,
-                                MX_DISPATCH_GETTER, MX_IGNORE_ENTITY_CATEGORY)
+                                MX_DISPATCH_GETTER)
 #undef MX_DISPATCH_GETTER
 
 
diff --git a/lib/InvalidEntityProvider.cpp b/lib/InvalidEntityProvider.cpp
index 886656d9f..47d45187b 100644
--- a/lib/InvalidEntityProvider.cpp
+++ b/lib/InvalidEntityProvider.cpp
@@ -100,8 +100,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
-                            MX_DECLARE_ENTITY_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY)
+                            MX_DECLARE_ENTITY_GETTER)
 #undef MX_DECLARE_ENTITY_GETTER
 
 #define MX_DECLARE_ENTITY_LISTERS(ns_path, type_name, lower_name, enum_name, category) \
@@ -114,7 +113,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_DECLARE_ENTITY_LISTERS,
                             MX_IGNORE_ENTITY_CATEGORY,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_ENTITY_LISTERS
 
diff --git a/lib/InvalidEntityProvider.h b/lib/InvalidEntityProvider.h
index 7806f2062..897d2bf26 100644
--- a/lib/InvalidEntityProvider.h
+++ b/lib/InvalidEntityProvider.h
@@ -74,8 +74,7 @@ class InvalidEntityProvider final : public EntityProvider {
                               MX_DECLARE_ENTITY_GETTER,
                               MX_DECLARE_ENTITY_GETTER,
                               MX_DECLARE_ENTITY_GETTER,
-                              MX_DECLARE_ENTITY_GETTER,
-                              MX_IGNORE_ENTITY_CATEGORY)
+                              MX_DECLARE_ENTITY_GETTER)
 #undef MX_DECLARE_ENTITY_GETTER
 
 #define MX_DECLARE_ENTITY_LISTERS(ns_path, type_name, lower_name, enum_name, category) \
@@ -88,7 +87,6 @@ class InvalidEntityProvider final : public EntityProvider {
                               MX_IGNORE_ENTITY_CATEGORY,
                               MX_DECLARE_ENTITY_LISTERS,
                               MX_IGNORE_ENTITY_CATEGORY,
-                              MX_IGNORE_ENTITY_CATEGORY,
                               MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_ENTITY_LISTERS
 };
diff --git a/lib/RPC.capnp b/lib/RPC.capnp
index d1ac7eb54..636c3e5d8 100644
--- a/lib/RPC.capnp
+++ b/lib/RPC.capnp
@@ -157,8 +157,7 @@ struct Fragment @0xe5f27760091f9a3a {
   relatedEntityId @14 :List(UInt64);
   
   # The translation unit from which this fragment was derived. We can find
-  # the compile command for a fragment there, if we need to reproduce the
-  # TU, and we can find its MLIR representation there too.
+  # the compile command for a fragment there, if we need to reproduce the TU.
   compilationId @15 :UInt64;
 
   # The entities from this fragment. These are lists-of-lists. The top-level
@@ -202,9 +201,6 @@ struct Compilation @0xc8b5fa5dd0739e82 {
   
   # The compile command for this compilation unit.
   command @6 :CompileCommand;
-  
-  # Source IR in text format
-  mlir @7 :Text;
 } 
 
 struct Type @0xd2d91de1b5fe2e03 {
diff --git a/lib/Reference.cpp b/lib/Reference.cpp
index 574239a9c..8d88b7f34 100644
--- a/lib/Reference.cpp
+++ b/lib/Reference.cpp
@@ -39,14 +39,9 @@ static OpaqueImplPtr ReferencedEntity(const EntityProviderPtr &ep,
     MX_FOR_EACH_ENTITY_CATEGORY(MX_DISPATCH_GETTER, MX_IGNORE_ENTITY_CATEGORY,
                                 MX_DISPATCH_GETTER, MX_DISPATCH_GETTER,
                                 MX_DISPATCH_GETTER, MX_DISPATCH_GETTER,
-                                MX_DISPATCH_GETTER, MX_IGNORE_ENTITY_CATEGORY)
+                                MX_DISPATCH_GETTER)
 #undef MX_DISPATCH_GETTER
 
-  // It's a reference to an IR oeration.
-  } else if (std::holds_alternative<OperationId>(vid)) {
-    // TODO(pag): Figure this out.
-    assert(false);
-
   // It's a reference to a parsed token resident in a fragment.
   } else if (std::holds_alternative<ParsedTokenId>(vid)) {
     ParsedTokenId id = std::get<ParsedTokenId>(vid);
@@ -254,7 +249,6 @@ VariantEntity Reference::as_variant(void) const noexcept {
                                 DEFINE_REF_GETTER,
                                 DEFINE_REF_GETTER,
                                 DEFINE_REF_GETTER,
-                                DEFINE_REF_GETTER,
                                 DEFINE_REF_GETTER)
 #undef DEFINE_REF_GETTER
   }
@@ -300,11 +294,6 @@ gap::generator<Reference> Reference::from(const VariantEntity &entity) {
   return EmptyReferences();
 }
 
-std::optional<::mx::ir::Operation> Reference::as_operation(void) const noexcept {
-  assert(false);  // TODO(pag): Implement me.
-  return std::nullopt;
-}
-
 #define DEFINE_REF_GETTER(ns_path, type_name, lower_name, enum_name, category_) \
     std::optional<ns_path type_name> \
     Reference::as_ ## lower_name (void) const noexcept { \
@@ -325,8 +314,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(DEFINE_REF_GETTER,
                             DEFINE_REF_GETTER,
                             DEFINE_REF_GETTER,
                             DEFINE_REF_GETTER,
-                            DEFINE_REF_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY)
+                            DEFINE_REF_GETTER)
 
 #undef DEFINE_REF_GETTER
 
diff --git a/lib/SQLiteEntityProvider.cpp b/lib/SQLiteEntityProvider.cpp
index 7edf45dd0..de25edf54 100644
--- a/lib/SQLiteEntityProvider.cpp
+++ b/lib/SQLiteEntityProvider.cpp
@@ -1078,8 +1078,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_ENTITY_GETTER,
                             MX_DECLARE_FRAGMENT_OFFSET_GETTER,
                             MX_DECLARE_FRAGMENT_PSEUDO_GETTER,
-                            MX_DECLARE_ENTITY_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY)
+                            MX_DECLARE_ENTITY_GETTER)
 #undef MX_DECLARE_ENTITY_GETTER
 #undef MX_DECLARE_FRAGMENT_OFFSET_GETTER
 #undef MX_DECLARE_FRAGMENT_PSEUDO_GETTER
@@ -1261,8 +1260,7 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_DECLARE_ENTITY_LIST_GETTER,
                             MX_DECLARE_ENTITY_LIST_GETTER,
                             MX_DECLARE_FRAGMENT_OFFSET_LIST_GETTER,
                             MX_DECLARE_FRAGMENT_PSEUDO_LIST_GETTER,
-                            MX_DECLARE_ENTITY_LIST_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY)
+                            MX_DECLARE_ENTITY_LIST_GETTER)
 
 #undef MX_DECLARE_ENTITY_LIST_GETTER
 #undef MX_DECLARE_FRAGMENT_OFFSET_LIST_GETTER
@@ -1384,7 +1382,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_DECLARE_FRAGMENT_OFFSET_LISTERS,
                             MX_IGNORE_ENTITY_CATEGORY,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_FRAGMENT_OFFSET_LISTERS
 
diff --git a/lib/SQLiteEntityProvider.h b/lib/SQLiteEntityProvider.h
index f44f4a2e0..b709f7ed7 100644
--- a/lib/SQLiteEntityProvider.h
+++ b/lib/SQLiteEntityProvider.h
@@ -105,8 +105,7 @@ class SQLiteEntityProvider final : public EntityProvider {
                               MX_DECLARE_ENTITY_GETTER,
                               MX_DECLARE_ENTITY_GETTER,
                               MX_DECLARE_ENTITY_GETTER,
-                              MX_DECLARE_ENTITY_GETTER,
-                              MX_IGNORE_ENTITY_CATEGORY)
+                              MX_DECLARE_ENTITY_GETTER)
 #undef MX_DECLARE_ENTITY_GETTER
 
 #define MX_DECLARE_ENTITY_LISTERS(ns_path, type_name, lower_name, enum_name, category) \
@@ -119,7 +118,6 @@ class SQLiteEntityProvider final : public EntityProvider {
                               MX_IGNORE_ENTITY_CATEGORY,
                               MX_DECLARE_ENTITY_LISTERS,
                               MX_IGNORE_ENTITY_CATEGORY,
-                              MX_IGNORE_ENTITY_CATEGORY,
                               MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DECLARE_ENTITY_LISTERS
 };
diff --git a/lib/Stmt.cpp b/lib/Stmt.cpp
index f1c38ba41..79c2b710c 100644
--- a/lib/Stmt.cpp
+++ b/lib/Stmt.cpp
@@ -5,6 +5,7 @@
 
 #include "Stmt.h"
 
+#include <algorithm>
 #include <multiplier/Index.h>
 #include <multiplier/Frontend/MacroSubstitution.h>
 
@@ -29,6 +30,27 @@ SpecificEntityId<StmtId> Stmt::id(void) const {
   return eid;
 }
 
+gap::generator<Stmt> Stmt::in(const Compilation &tu) {
+  auto frags = tu.fragments();
+  for (Fragment frag : frags) {
+    for (Stmt stmt : Stmt::in(frag)) {
+      co_yield std::move(stmt);
+    }
+  }
+}
+
+gap::generator<Stmt> Stmt::in(const Compilation &tu,
+                              std::span<const StmtKind> kinds) {
+  auto frags = tu.fragments();
+  for (Fragment frag : frags) {
+    for (Stmt stmt : Stmt::in(frag)) {
+      if (std::find(kinds.begin(), kinds.end(), stmt.kind()) != kinds.end()) {
+        co_yield std::move(stmt);
+      }
+    }
+  }
+}
+
 // Public methods for derived classes
 
 // Included to make sure to distinguish from `call_return_type`
diff --git a/lib/TokenContext.cpp b/lib/TokenContext.cpp
index d4eb66ddf..9d72160cc 100644
--- a/lib/TokenContext.cpp
+++ b/lib/TokenContext.cpp
@@ -34,7 +34,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_DEFINE_GETTER,
                             MX_DEFINE_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DEFINE_GETTER
 
@@ -75,7 +74,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_DEFINE_GETTER,
                             MX_DEFINE_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DEFINE_GETTER
 
@@ -157,7 +155,6 @@ VariantEntity TokenContext::as_variant(void) const noexcept {
                                 MX_IGNORE_ENTITY_CATEGORY,
                                 MX_DEFINE_GETTER,
                                 MX_DEFINE_GETTER,
-                                MX_IGNORE_ENTITY_CATEGORY,
                                 MX_IGNORE_ENTITY_CATEGORY)
     default: break;
   }
@@ -179,7 +176,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_DEFINE_GETTER,
                             MX_DEFINE_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_DEFINE_GETTER
 
diff --git a/lib/TokenContext.h b/lib/TokenContext.h
index 80aba1173..25f36dcef 100644
--- a/lib/TokenContext.h
+++ b/lib/TokenContext.h
@@ -25,7 +25,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_FORWARD_DECLARE_GETTER,
                             MX_FORWARD_DECLARE_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_FORWARD_DECLARE_GETTER
 
@@ -56,7 +55,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_FORWARD_DECLARE_GETTER,
                             MX_FORWARD_DECLARE_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_FORWARD_DECLARE_GETTER
 
@@ -86,7 +84,6 @@ MX_FOR_EACH_ENTITY_CATEGORY(MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY,
                             MX_FORWARD_DECLARE_GETTER,
                             MX_FORWARD_DECLARE_GETTER,
-                            MX_IGNORE_ENTITY_CATEGORY,
                             MX_IGNORE_ENTITY_CATEGORY)
 #undef MX_FORWARD_DECLARE_GETTER
 
diff --git a/lib/Types.cpp b/lib/Types.cpp
index 9712fadc5..a397b7409 100644
--- a/lib/Types.cpp
+++ b/lib/Types.cpp
@@ -13,8 +13,6 @@
 #include <multiplier/Frontend/File.h>
 #include <multiplier/Frontend/Macro.h>
 #include <multiplier/Frontend/TokenKind.h>
-#include <multiplier/IR/Operation.h>
-#include <multiplier/IR/OperationKind.h>
 
 namespace mx {
 namespace {
@@ -27,7 +25,6 @@ enum OtherKind : uint64_t {
   kFileToken,
   kTypeToken,
   kCompilation,
-  kOperation
 };
 
 // A code chunk with many tokens.
@@ -49,8 +46,6 @@ static constexpr uint64_t kNumTypeKinds = NumEnumerators(TypeKind{});
 static constexpr uint64_t kNumAttrKinds = NumEnumerators(AttrKind{});
 static constexpr uint64_t kNumTokenKinds = NumEnumerators(TokenKind{});
 static constexpr uint64_t kNumMacroKinds = NumEnumerators(MacroKind{});
-static constexpr uint64_t kNumOperationKinds
-    = NumEnumerators(ir::OperationKind{});
 
 // NOTE(pag): Keep up-to-date with `IdentifiedPseudo`.
 static constexpr uint64_t kNumPseudoKinds = 5u;
@@ -63,7 +58,6 @@ static_assert((kNumDeclKinds + kNumStmtKinds + kNumAttrKinds +
                kNumPseudoKinds) <=
               (1u << kSubKindNumBits));
 
-static constexpr uint64_t kNumOperationLevelBits = 3u;
 static constexpr unsigned kOtherKindBits = 3u;
 static constexpr unsigned kTokenKindNumBits = 9u;
 static_assert(NumEnumerators(TokenKind{}) <= (1u << kTokenKindNumBits));
@@ -71,9 +65,6 @@ static_assert(NumEnumerators(TokenKind{}) <= (1u << kTokenKindNumBits));
 static constexpr unsigned kTypeKindNumBits = 6u;
 static_assert(kNumTypeKinds <= (1u << kTypeKindNumBits));
 
-static constexpr unsigned kOperationKindNumBits = 10u;
-static_assert(kNumOperationKinds <= (1u << kOperationKindNumBits));
-
 // A small X is a token in a code with less than `kNumTokensInBigCode`
 // tokens, and so we only need `kBigCodeIdNumBits` bits to represent the
 // maximum token offset.
@@ -183,15 +174,6 @@ union PackedEntityId {
     uint64_t is_fragment_entity:1u;
   } __attribute__((packed)) compilation;
 
-  struct {
-    uint64_t offset:24u;
-    uint64_t level:kNumOperationLevelBits;
-    uint64_t operation_kind:kOperationKindNumBits;
-    uint64_t compilation_id:23u;
-    uint64_t kind:kOtherKindBits;
-    uint64_t is_fragment_entity:1u;
-  } __attribute__((packed)) operation;
-
 } __attribute__((packed));
 
 static_assert(sizeof(PackedEntityId) == sizeof(uint64_t));
@@ -210,7 +192,6 @@ const char *EnumeratorName(EntityCategory e) noexcept {
                                 MX_ENTITY_CASE_NAME,
                                 MX_ENTITY_CASE_NAME,
                                 MX_ENTITY_CASE_NAME,
-                                MX_ENTITY_CASE_NAME,
                                 MX_ENTITY_CASE_NAME)
 #undef MX_ENTITY_CASE_NAME
   }
@@ -730,35 +711,6 @@ EntityId::EntityId(CompilationId id) {
   }
 }
 
-EntityId::EntityId(OperationId id) {
-  if (id.compilation_id && id.kind != ir::OperationKind::UNKNOWN) {
-    PackedEntityId packed = {};
-    packed.operation.is_fragment_entity = 0u;
-
-    packed.operation.compilation_id = id.compilation_id;
-    RETURN_EARLY_IF_NOT(packed.operation.compilation_id == id.compilation_id);
-
-    packed.operation.offset = id.offset;
-    RETURN_EARLY_IF_NOT(packed.operation.offset == id.offset);
-
-    packed.operation.level = id.level;
-    RETURN_EARLY_IF_NOT(packed.operation.level == id.level);
-
-    packed.operation.operation_kind = static_cast<uint64_t>(id.kind);
-    RETURN_EARLY_IF_NOT(packed.operation.operation_kind <= kNumOperationKinds);
-
-    packed.operation.kind =
-        static_cast<uint64_t>(OtherKind::kOperation);
-    opaque = packed.opaque;
-
-#ifndef NDEBUG
-    auto unpacked = Unpack();
-    assert(std::holds_alternative<OperationId>(unpacked));
-    assert(std::get<OperationId>(unpacked) == id);
-#endif
-  }
-}
-
 EntityId::EntityId(FileTokenId id) {
   if (id.file_id) {
     PackedEntityId packed = {};
@@ -791,7 +743,6 @@ struct IDFragment {
   inline int operator()(FileId) const noexcept { return mx::kInvalidEntityId; }
   inline int operator()(FileTokenId) const noexcept { return mx::kInvalidEntityId; }
   inline int operator()(CompilationId) const noexcept { return mx::kInvalidEntityId; }
-  inline int operator()(OperationId) const noexcept { return mx::kInvalidEntityId; }
   inline int operator()(TypeId) const noexcept { return mx::kInvalidEntityId; }
   inline int operator()(TypeTokenId) const noexcept { return mx::kInvalidEntityId; }
 
@@ -806,7 +757,6 @@ struct IDFragmentOffset {
   inline int operator()(FileId) const noexcept { return mx::kInvalidEntityId; }
   inline int operator()(FileTokenId) const noexcept { return mx::kInvalidEntityId; }
   inline int operator()(CompilationId) const noexcept { return mx::kInvalidEntityId; }
-  inline int operator()(OperationId) const noexcept { return mx::kInvalidEntityId; }
   inline int operator()(TypeId) const noexcept { return mx::kInvalidEntityId; }
   inline int operator()(TypeTokenId) const noexcept { return mx::kInvalidEntityId; }
 
@@ -827,7 +777,7 @@ struct IDKind {
   inline int operator()(CXXCtorInitializerId) const noexcept { return -1; }
   inline int operator()(CompilationId) const noexcept { return -1; }
 
-  // Applies to tokens, operations, decls, statements, types, attributes, etc.
+  // Applies to tokens, decls, statements, types, attributes, etc.
   template <typename T>
   inline int operator()(T t) const noexcept {
     return static_cast<int>(t.kind);
@@ -889,9 +839,6 @@ struct IDCategory {
   inline EntityCategory operator()(CompilationId) const noexcept {
     return EntityCategory::COMPILATION;
   }
-  inline EntityCategory operator()(OperationId) const noexcept {
-    return EntityCategory::OPERATION;
-  }
   template <typename T>
   inline EntityCategory operator()(T) const noexcept {
     assert(false);
@@ -1259,18 +1206,6 @@ VariantId EntityId::Unpack(void) const noexcept {
         }
         break;
       }
-      case OtherKind::kOperation: {
-        if (packed.operation.compilation_id &&
-            packed.operation.operation_kind &&
-            packed.operation.operation_kind < kNumOperationKinds) {
-          return OperationId(
-              packed.operation.compilation_id,
-              static_cast<ir::OperationKind>(packed.operation.operation_kind),
-              packed.operation.offset,
-              packed.operation.level);
-        }
-        break;
-      }
     }
   }
 
diff --git a/vendor/CMakeLists.txt b/vendor/CMakeLists.txt
index 4465b652b..0120657f6 100644
--- a/vendor/CMakeLists.txt
+++ b/vendor/CMakeLists.txt
@@ -21,7 +21,6 @@ add_subdirectory(rocksdb)  # Depends on zstd, gflags
 add_subdirectory(llvm-project)  # Depends on zstd
 add_subdirectory(pasta)  # Depends on llvm-project
 add_subdirectory(gap)  # Depends on llvm-project
-add_subdirectory(vast)  # Depends on gap, llvm-project
 add_subdirectory(intervaltree)
 
 if(MX_ENABLE_RE2)
diff --git a/vendor/abseil/CMakeLists.txt b/vendor/abseil/CMakeLists.txt
index c9d56d406..e88cb788d 100644
--- a/vendor/abseil/CMakeLists.txt
+++ b/vendor/abseil/CMakeLists.txt
@@ -30,6 +30,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
diff --git a/vendor/capnproto/CMakeLists.txt b/vendor/capnproto/CMakeLists.txt
index 4108267b2..438855e90 100644
--- a/vendor/capnproto/CMakeLists.txt
+++ b/vendor/capnproto/CMakeLists.txt
@@ -36,6 +36,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
diff --git a/vendor/gap/CMakeLists.txt b/vendor/gap/CMakeLists.txt
index 4fa15fda2..cffccf389 100644
--- a/vendor/gap/CMakeLists.txt
+++ b/vendor/gap/CMakeLists.txt
@@ -17,7 +17,6 @@ if(NOT MX_USE_VENDORED_GAP)
 endif()
 
 find_package(LLVM CONFIG REQUIRED QUIET HINTS "${MX_VENDOR_INSTALL_DIR}")
-find_package(MLIR CONFIG REQUIRED QUIET HINTS "${MX_VENDOR_INSTALL_DIR}")
 find_package(Clang CONFIG REQUIRED QUIET HINTS "${MX_VENDOR_INSTALL_DIR}")
 
 set(src_dir "${CMAKE_CURRENT_LIST_DIR}/src")
@@ -40,6 +39,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 #            distribute.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
@@ -56,10 +56,9 @@ execute_process(COMMAND ${CMAKE_COMMAND}
                         -DGAP_ENABLE_VCPKG:BOOL=OFF
                         -DGAP_ENABLE_WARNINGS:BOOL=OFF
                         -DGAP_ENABLE_SARIF:BOOL=OFF
-                        -DGAP_ENABLE_MLIR:BOOL=ON
+                        -DGAP_ENABLE_MLIR:BOOL=OFF
                         -DGAP_INSTALL:BOOL=ON
                         "-DLLVM_DIR=${LLVM_DIR}"
-                        "-DMLIR_DIR=${MLIR_DIR}"
                         "-DClang_DIR=${Clang_DIR}"
                         "${src_dir}"
                WORKING_DIRECTORY "${build_dir}")
diff --git a/vendor/gflags/CMakeLists.txt b/vendor/gflags/CMakeLists.txt
index d270e5ae2..4e94e536b 100644
--- a/vendor/gflags/CMakeLists.txt
+++ b/vendor/gflags/CMakeLists.txt
@@ -42,6 +42,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
diff --git a/vendor/glog/CMakeLists.txt b/vendor/glog/CMakeLists.txt
index 379a024cc..a837b1bd4 100644
--- a/vendor/glog/CMakeLists.txt
+++ b/vendor/glog/CMakeLists.txt
@@ -32,6 +32,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
diff --git a/vendor/llvm-project/CMakeLists.txt b/vendor/llvm-project/CMakeLists.txt
index 0c1dcc778..408188179 100644
--- a/vendor/llvm-project/CMakeLists.txt
+++ b/vendor/llvm-project/CMakeLists.txt
@@ -7,10 +7,9 @@
 
 if(NOT MX_USE_VENDORED_CLANG)
   find_package(LLVM CONFIG QUIET)
-  find_package(MLIR CONFIG QUIET)
   find_package(Clang CONFIG QUIET)
 
-  if(LLVM_FOUND AND MLIR_FOUND AND Clang_FOUND)
+  if(LLVM_FOUND AND Clang_FOUND)
     return()
   endif()
 endif()
@@ -30,7 +29,7 @@ if(NOT EXISTS "${src_dir}/llvm/CMakeLists.txt")
 endif()
 
 # This is the main build, setup and execute the nested build
-# to ensure the Clang and MLIR libraries exist before continuing
+# to ensure the Clang library exists before continuing
 
 # NOTE(pag): C++17 seems to be needed when building Clang on Linux, due to uses
 #            of `__is_constructible`.
@@ -63,7 +62,7 @@ execute_process(COMMAND ${CMAKE_COMMAND}
                         -DCMAKE_CXX_STANDARD=17
                         "-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=${CMAKE_INTERPROCEDURAL_OPTIMIZATION}"
                         -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
-                        "-DLLVM_ENABLE_PROJECTS=clang;mlir"
+                        "-DLLVM_ENABLE_PROJECTS=clang"
                         "-DLLVM_TARGETS_TO_BUILD=AArch64;X86;ARM"
                         "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=ARM;WebAssembly"
                         "-DLLVM_ENABLE_RUNTIMES=libcxx;libcxxabi"
@@ -104,5 +103,4 @@ execute_process(COMMAND ${CMAKE_COMMAND} --build . --target install
                 WORKING_DIRECTORY "${build_dir}")
 
 find_package(LLVM CONFIG REQUIRED HINTS "${MX_VENDOR_INSTALL_DIR}" NO_DEFAULT_PATH)
-find_package(MLIR CONFIG REQUIRED HINTS "${MX_VENDOR_INSTALL_DIR}" NO_DEFAULT_PATH)
 find_package(Clang CONFIG REQUIRED PATHS "${MX_VENDOR_INSTALL_DIR}" NO_DEFAULT_PATH)
diff --git a/vendor/pasta/CMakeLists.txt b/vendor/pasta/CMakeLists.txt
index 262c7ab16..6c3742b27 100644
--- a/vendor/pasta/CMakeLists.txt
+++ b/vendor/pasta/CMakeLists.txt
@@ -33,6 +33,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
diff --git a/vendor/re2/CMakeLists.txt b/vendor/re2/CMakeLists.txt
index afbf28c9c..305902bf8 100644
--- a/vendor/re2/CMakeLists.txt
+++ b/vendor/re2/CMakeLists.txt
@@ -32,6 +32,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
diff --git a/vendor/reproc/CMakeLists.txt b/vendor/reproc/CMakeLists.txt
index dc865dc75..9007460a2 100644
--- a/vendor/reproc/CMakeLists.txt
+++ b/vendor/reproc/CMakeLists.txt
@@ -39,6 +39,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
diff --git a/vendor/rocksdb/CMakeLists.txt b/vendor/rocksdb/CMakeLists.txt
index 5776d07af..684e3b493 100644
--- a/vendor/rocksdb/CMakeLists.txt
+++ b/vendor/rocksdb/CMakeLists.txt
@@ -42,6 +42,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
diff --git a/vendor/vast/CMakeLists.txt b/vendor/vast/CMakeLists.txt
deleted file mode 100644
index da9b2100d..000000000
--- a/vendor/vast/CMakeLists.txt
+++ /dev/null
@@ -1,74 +0,0 @@
-#
-# Copyright (c) 2023-present, Trail of Bits, Inc.
-#
-# This source code is licensed in accordance with the terms specified in
-# the LICENSE file found in the root directory of this source tree.
-#
-
-if(NOT MX_USE_VENDORED_VAST)
-  find_package(VAST CONFIG QUIET)
-  if(VAST_FOUND)
-    return()
-  endif()
-endif()
-
-find_package(gap CONFIG REQUIRED QUIET)
-find_package(LLVM CONFIG REQUIRED QUIET HINTS "${MX_VENDOR_INSTALL_DIR}")
-find_package(MLIR CONFIG REQUIRED QUIET HINTS "${MX_VENDOR_INSTALL_DIR}")
-find_package(Clang CONFIG REQUIRED QUIET HINTS "${MX_VENDOR_INSTALL_DIR}")
-
-set(src_dir "${CMAKE_CURRENT_LIST_DIR}/src")
-set(build_dir "${CMAKE_CURRENT_BINARY_DIR}/build")
-
-# Fetch the submodule if we don't yet have it.
-if(NOT EXISTS "${src_dir}/CMakeLists.txt")
-  execute_process(
-    COMMAND "${GIT_EXECUTABLE}" submodule update --init vendor/vast/src
-    WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}")
-
-  execute_process(
-    COMMAND "${GIT_EXECUTABLE}" submodule set-branch --branch mx_codegen vendor/vast/src
-    WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}")
-endif()
-
-# This is the main build, setup and execute the nested build
-# to ensure the pasta library exists before continuing
-
-execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
-
-# (b) Nested CMake run. May need more -D... options than shown here.
-execute_process(COMMAND ${CMAKE_COMMAND}
-                        -G "${CMAKE_GENERATOR}"
-                        "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-                        "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
-                        "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
-                        "-DCMAKE_INSTALL_RPATH=${CMAKE_INSTALL_RPATH}"
-                        "-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}"
-                        "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
-                        "-DCMAKE_LINKER_TYPE=${CMAKE_LINKER_TYPE}"
-                        "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
-                        "-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=${CMAKE_INTERPROCEDURAL_OPTIMIZATION}"
-                        -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
-                        -DVAST_ENABLE_GAP_SUBMODULE:BOOL=FALSE
-                        -DVAST_WARNINGS_AS_ERRORS:BOOL=FALSE
-                        -DVAST_ENABLE_TESTING:BOOL=OFF
-                        -DVAST_GENERATE_TOOLS:BOOL=OFF
-                        -DVAST_BUILD_TOOLS:BOOL=OFF
-                        -DVAST_BUILD_FRONTEND:BOOL=ON
-                        -DVAST_ENABLE_EXCEPTIONS:BOOL=ON
-                        "-Dgap_DIR=${gap_DIR}"
-                        "-DLLVM_DIR=${LLVM_DIR}"
-                        "-DMLIR_DIR=${MLIR_DIR}"
-                        "-DClang_DIR=${Clang_DIR}"
-                        "${src_dir}"
-               WORKING_DIRECTORY "${build_dir}"
-               COMMAND_ECHO STDOUT)
-
-# (c) Build just mycomp in the nested build. Don't specify a --config
-#     because we cannot know what config the developer will be using
-#     at this point. For non-multi-config generators, we've already
-#     specified CMAKE_BUILD_TYPE above in (b).
-execute_process(COMMAND ${CMAKE_COMMAND} --build . --target install
-                WORKING_DIRECTORY "${build_dir}")
-
-find_package(VAST CONFIG REQUIRED HINTS "${MX_VENDOR_INSTALL_DIR}" NO_DEFAULT_PATH)
diff --git a/vendor/vast/src b/vendor/vast/src
deleted file mode 160000
index dc94ac93b..000000000
--- a/vendor/vast/src
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit dc94ac93b5efdf40e392febe9e30fe723564628d
diff --git a/vendor/xxhash/CMakeLists.txt b/vendor/xxhash/CMakeLists.txt
index a1010a2ff..e18cb8c36 100644
--- a/vendor/xxhash/CMakeLists.txt
+++ b/vendor/xxhash/CMakeLists.txt
@@ -30,6 +30,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"
diff --git a/vendor/zstd/CMakeLists.txt b/vendor/zstd/CMakeLists.txt
index 9ec5b7224..80cea49cb 100644
--- a/vendor/zstd/CMakeLists.txt
+++ b/vendor/zstd/CMakeLists.txt
@@ -30,6 +30,7 @@ execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory "${build_dir}")
 # (b) Nested CMake run. May need more -D... options than shown here.
 execute_process(COMMAND ${CMAKE_COMMAND}
                         -G "${CMAKE_GENERATOR}"
+                        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
                         "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
                         "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                         "-DCMAKE_INSTALL_PREFIX=${MX_VENDOR_INSTALL_DIR}"